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.
9649 Commits
32 Branches
2.1GB
Tree: 4d9a577e30
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from '4d9a577e30'
${ noResults }
FFmpeg/libavformat/mpegts.c

1517 lines
43KB
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. #include "allformats.h"

  25. 

  26. //#define DEBUG_SI

  27. //#define DEBUG_SEEK

  28. 

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

  30. #define MAX_SCAN_PACKETS 32000

  31. 

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

  33.    synchronisation is lost */

  34. #define MAX_RESYNC_SIZE 4096

  35. 

  36. typedef struct PESContext PESContext;

  37. 

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

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

  40. 

  41. enum MpegTSFilterType {

  42.     MPEGTS_PES,

  43.     MPEGTS_SECTION,

  44. };

  45. 

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

  47. 

  48. typedef struct MpegTSPESFilter {

  49.     PESCallback *pes_cb;

  50.     void *opaque;

  51. } MpegTSPESFilter;

  52. 

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

  54. 

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

  56. 

  57. typedef struct MpegTSSectionFilter {

  58.     int section_index;

  59.     int section_h_size;

  60.     uint8_t *section_buf;

  61.     int check_crc:1;

  62.     int end_of_section_reached:1;

  63.     SectionCallback *section_cb;

  64.     void *opaque;

  65. } MpegTSSectionFilter;

  66. 

  67. typedef struct MpegTSFilter {

  68.     int pid;

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

  70.     enum MpegTSFilterType type;

  71.     union {

  72.         MpegTSPESFilter pes_filter;

  73.         MpegTSSectionFilter section_filter;

  74.     } u;

  75. } MpegTSFilter;

  76. 

  77. typedef struct MpegTSService {

  78.     int running:1;

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

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

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

  82. } MpegTSService;

  83. 

  84. struct MpegTSContext {

  85.     /* user data */

  86.     AVFormatContext *stream;

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

  88.     int raw_packet_size;

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

  90.     int auto_guess;

  91. 

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

  93.     int mpeg2ts_compute_pcr;

  94. 

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

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

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

  98. 

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

  100.     /** stop parsing loop                                    */

  101.     int stop_parse;

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

  103.     AVPacket *pkt;

  104. 

  105.     /******************************************/

  106.     /* private mpegts data */

  107.     /* scan context */

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

  109.     int nb_services;

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

  111.     MpegTSService **services;

  112. 

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

  114.     int req_sid;

  115. 

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

  117.     MpegTSFilter *pids[NB_PID_MAX];

  118. };

  119. 

  120. /**

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

  122.  *  function when they are complete.

  123.  */

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

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

  126. {

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

  128.     int len;

  129. 

  130.     if (is_start) {

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

  132.         tss->section_index = buf_size;

  133.         tss->section_h_size = -1;

  134.         tss->end_of_section_reached = 0;

  135.     } else {

  136.         if (tss->end_of_section_reached)

  137.             return;

  138.         len = 4096 - tss->section_index;

  139.         if (buf_size < len)

  140.             len = buf_size;

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

  142.         tss->section_index += len;

  143.     }

  144. 

  145.     /* compute section length if possible */

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

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

  148.         if (len > 4096)

  149.             return;

  150.         tss->section_h_size = len;

  151.     }

  152. 

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

  154.         tss->end_of_section_reached = 1;

  155.         if (!tss->check_crc ||

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

  157.             tss->section_cb(tss1, tss->section_buf, tss->section_h_size);

  158.     }

  159. }

  160. 

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

  162.                                          SectionCallback *section_cb, void *opaque,

  163.                                          int check_crc)

  164. 

  165. {

  166.     MpegTSFilter *filter;

  167.     MpegTSSectionFilter *sec;

  168. 

  169. #ifdef DEBUG_SI

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

  171. #endif

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

  173.         return NULL;

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

  175.     if (!filter)

  176.         return NULL;

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

  178.     filter->type = MPEGTS_SECTION;

  179.     filter->pid = pid;

  180.     filter->last_cc = -1;

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

  182.     sec->section_cb = section_cb;

  183.     sec->opaque = opaque;

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

  185.     sec->check_crc = check_crc;

  186.     if (!sec->section_buf) {

  187.         av_free(filter);

  188.         return NULL;

  189.     }

  190.     return filter;

  191. }

  192. 

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

  194.                                      PESCallback *pes_cb,

  195.                                      void *opaque)

  196. {

  197.     MpegTSFilter *filter;

  198.     MpegTSPESFilter *pes;

  199. 

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

  201.         return NULL;

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

  203.     if (!filter)

  204.         return NULL;

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

  206.     filter->type = MPEGTS_PES;

  207.     filter->pid = pid;

  208.     filter->last_cc = -1;

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

  210.     pes->pes_cb = pes_cb;

  211.     pes->opaque = opaque;

  212.     return filter;

  213. }

  214. 

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

  216. {

  217.     int pid;

  218. 

  219.     pid = filter->pid;

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

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

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

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

  224. 

  225.     av_free(filter);

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

  227. }

  228. 

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

  230.     int stat[packet_size];

  231.     int i;

  232.     int x=0;

  233.     int best_score=0;

  234. 

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

  236. 

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

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

  239.             stat[x]++;

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

  241.                 best_score= stat[x];

  242.                 if(index) *index= x;

  243.             }

  244.         }

  245. 

  246.         x++;

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

  248.     }

  249. 

  250.     return best_score;

  251. }

  252. 

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

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

  255. {

  256.     int score, fec_score, dvhs_score;

  257. 

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

  259.         return -1;

  260. 

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

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

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

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

  265. 

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

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

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

  269.     else                       return -1;

  270. }

  271. 

  272. typedef struct SectionHeader {

  273.     uint8_t tid;

  274.     uint16_t id;

  275.     uint8_t version;

  276.     uint8_t sec_num;

  277.     uint8_t last_sec_num;

  278. } SectionHeader;

  279. 

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

  281. {

  282.     const uint8_t *p;

  283.     int c;

  284. 

  285.     p = *pp;

  286.     if (p >= p_end)

  287.         return -1;

  288.     c = *p++;

  289.     *pp = p;

  290.     return c;

  291. }

  292. 

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

  294. {

  295.     const uint8_t *p;

  296.     int c;

  297. 

  298.     p = *pp;

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

  300.         return -1;

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

  302.     p += 2;

  303.     *pp = p;

  304.     return c;

  305. }

  306. 

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

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

  309. {

  310.     int len;

  311.     const uint8_t *p;

  312.     char *str;

  313. 

  314.     p = *pp;

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

  316.     if (len < 0)

  317.         return NULL;

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

  319.         return NULL;

  320.     str = av_malloc(len + 1);

  321.     if (!str)

  322.         return NULL;

  323.     memcpy(str, p, len);

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

  325.     p += len;

  326.     *pp = p;

  327.     return str;

  328. }

  329. 

  330. static int parse_section_header(SectionHeader *h,

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

  332. {

  333.     int val;

  334. 

  335.     val = get8(pp, p_end);

  336.     if (val < 0)

  337.         return -1;

  338.     h->tid = val;

  339.     *pp += 2;

  340.     val = get16(pp, p_end);

  341.     if (val < 0)

  342.         return -1;

  343.     h->id = val;

  344.     val = get8(pp, p_end);

  345.     if (val < 0)

  346.         return -1;

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

  348.     val = get8(pp, p_end);

  349.     if (val < 0)

  350.         return -1;

  351.     h->sec_num = val;

  352.     val = get8(pp, p_end);

  353.     if (val < 0)

  354.         return -1;

  355.     h->last_sec_num = val;

  356.     return 0;

  357. }

  358. 

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

  360.                                   char *provider_name, char *name)

  361. {

  362.     MpegTSService *service=NULL;

  363.     int i;

  364. 

  365. #ifdef DEBUG_SI

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

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

  368.            sid, provider_name, name);

  369. #endif

  370. 

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

  372.         if(ts->services[i]->sid == sid)

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

  374. 

  375.     if(!service){

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

  377.         if (!service)

  378.             return NULL;

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

  380.     }

  381.     service->sid = sid;

  382.     assert((!provider_name) == (!name));

  383.     if(name){

  384.         av_free(service->provider_name);

  385.         av_free(service->         name);

  386.         service->provider_name = provider_name;

  387.         service->         name =          name;

  388.     }

  389.     return service;

  390. }

  391. 

  392. static void pmt_cb(MpegTSFilter *filter, const uint8_t *section, int section_len)

  393. {

  394.     MpegTSContext *ts = filter->u.section_filter.opaque;

  395.     SectionHeader h1, *h = &h1;

  396.     PESContext *pes;

  397.     AVStream *st;

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

  399.     int program_info_length, pcr_pid, pid, stream_type;

  400.     int desc_list_len, desc_len, desc_tag;

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

  402.     char language[4] = {0}; /* initialize to kill warnings */

  403. 

  404. #ifdef DEBUG_SI

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

  406.     av_hex_dump_log(ts->stream, AV_LOG_DEBUG, (uint8_t *)section, section_len);

  407. #endif

  408.     p_end = section + section_len - 4;

  409.     p = section;

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

  411.         return;

  412. #ifdef DEBUG_SI

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

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

  415. #endif

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

  417.         return;

  418. 

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

  420.     if (pcr_pid < 0)

  421.         return;

  422.     ts->pcr_pid = pcr_pid;

  423. #ifdef DEBUG_SI

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

  425. #endif

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

  427.     if (program_info_length < 0)

  428.         return;

  429.     p += program_info_length;

  430.     if (p >= p_end)

  431.         return;

  432.     for(;;) {

  433.         language[0] = 0;

  434.         st = 0;

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

  436.         if (stream_type < 0)

  437.             break;

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

  439.         if (pid < 0)

  440.             break;

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

  442.         if (desc_list_len < 0)

  443.             break;

  444.         desc_list_end = p + desc_list_len;

  445.         if (desc_list_end > p_end)

  446.             break;

  447.         for(;;) {

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

  449.             if (desc_tag < 0)

  450.                 break;

  451.             if (stream_type == STREAM_TYPE_PRIVATE_DATA) {

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

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

  454.                     stream_type = STREAM_TYPE_AUDIO_AC3;

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

  456.                     /* DVB DTS audio */

  457.                     stream_type = STREAM_TYPE_AUDIO_DTS;

  458.                 }

  459.             }

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

  461.             desc_end = p + desc_len;

  462.             if (desc_end > desc_list_end)

  463.                 break;

  464. #ifdef DEBUG_SI

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

  466.                    desc_tag, desc_len);

  467. #endif

  468.             switch(desc_tag) {

  469.             case DVB_SUBT_DESCID:

  470.                 if (stream_type == STREAM_TYPE_PRIVATE_DATA)

  471.                     stream_type = STREAM_TYPE_SUBTITLE_DVB;

  472. 

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

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

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

  476.                 language[3] = 0;

  477.                 get8(&p, desc_end);

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

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

  480. 

  481.                 break;

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

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

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

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

  486.                 language[3] = 0;

  487.                 break;

  488.             default:

  489.                 break;

  490.             }

  491.             p = desc_end;

  492.         }

  493.         p = desc_list_end;

  494. 

  495. #ifdef DEBUG_SI

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

  497.                stream_type, pid);

  498. #endif

  499. 

  500.         /* now create ffmpeg stream */

  501.         switch(stream_type) {

  502.         case STREAM_TYPE_AUDIO_MPEG1:

  503.         case STREAM_TYPE_AUDIO_MPEG2:

  504.         case STREAM_TYPE_VIDEO_MPEG1:

  505.         case STREAM_TYPE_VIDEO_MPEG2:

  506.         case STREAM_TYPE_VIDEO_MPEG4:

  507.         case STREAM_TYPE_VIDEO_H264:

  508.         case STREAM_TYPE_VIDEO_VC1:

  509.         case STREAM_TYPE_AUDIO_AAC:

  510.         case STREAM_TYPE_AUDIO_AC3:

  511.         case STREAM_TYPE_AUDIO_DTS:

  512.         case STREAM_TYPE_SUBTITLE_DVB:

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

  514.             if (pes)

  515.                 st = new_pes_av_stream(pes, 0);

  516.             break;

  517.         default:

  518.             /* we ignore the other streams */

  519.             break;

  520.         }

  521. 

  522.         if (st) {

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

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

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

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

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

  528.             }

  529. 

  530.             if (stream_type == STREAM_TYPE_SUBTITLE_DVB) {

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

  532.             }

  533.         }

  534.     }

  535.     /* all parameters are there */

  536.     ts->stop_parse=1;

  537.     mpegts_close_filter(ts, filter);

  538. }

  539. 

  540. static void pat_cb(MpegTSFilter *filter, const uint8_t *section, int section_len)

  541. {

  542.     MpegTSContext *ts = filter->u.section_filter.opaque;

  543.     SectionHeader h1, *h = &h1;

  544.     const uint8_t *p, *p_end;

  545.     int sid, pmt_pid;

  546. 

  547. #ifdef DEBUG_SI

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

  549.     av_hex_dump_log(ts->stream, AV_LOG_DEBUG, (uint8_t *)section, section_len);

  550. #endif

  551.     p_end = section + section_len - 4;

  552.     p = section;

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

  554.         return;

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

  556.         return;

  557. 

  558.     for(;;) {

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

  560.         if (sid < 0)

  561.             break;

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

  563.         if (pmt_pid < 0)

  564.             break;

  565. #ifdef DEBUG_SI

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

  567. #endif

  568.         if (sid == 0x0000) {

  569.             /* NIT info */

  570.         } else {

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

  572.                 mpegts_open_section_filter(ts, pmt_pid,

  573.                                                             pmt_cb, ts, 1);

  574.                 goto found;

  575.             }

  576.         }

  577.     }

  578.     /* not found */

  579.     ts->stop_parse=1;

  580. 

  581.  found:

  582.     mpegts_close_filter(ts, filter);

  583. }

  584. 

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

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

  587. {

  588.     MpegTSContext *ts = filter->u.section_filter.opaque;

  589.     SectionHeader h1, *h = &h1;

  590.     const uint8_t *p, *p_end;

  591.     int sid, pmt_pid;

  592. 

  593. #ifdef DEBUG_SI

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

  595.     av_hex_dump_log(ts->stream, AV_LOG_DEBUG, (uint8_t *)section, section_len);

  596. #endif

  597.     p_end = section + section_len - 4;

  598.     p = section;

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

  600.         return;

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

  602.         return;

  603. 

  604.     for(;;) {

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

  606.         if (sid < 0)

  607.             break;

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

  609.         if (pmt_pid < 0)

  610.             break;

  611. #ifdef DEBUG_SI

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

  613. #endif

  614.         if (sid == 0x0000) {

  615.             /* NIT info */

  616.         } else {

  617.             new_service(ts, sid, NULL, NULL);

  618.         }

  619.     }

  620.     ts->stop_parse = 1;

  621. 

  622.     /* remove filter */

  623.     mpegts_close_filter(ts, filter);

  624. }

  625. 

  626. static void mpegts_set_service(MpegTSContext *ts, int sid)

  627. {

  628.     ts->req_sid = sid;

  629.     mpegts_open_section_filter(ts, PAT_PID,

  630.                                                 pat_cb, ts, 1);

  631. }

  632. 

  633. static void sdt_cb(MpegTSFilter *filter, const uint8_t *section, int section_len)

  634. {

  635.     MpegTSContext *ts = filter->u.section_filter.opaque;

  636.     SectionHeader h1, *h = &h1;

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

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

  639.     char *name, *provider_name;

  640. 

  641. #ifdef DEBUG_SI

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

  643.     av_hex_dump_log(ts->stream, AV_LOG_DEBUG, (uint8_t *)section, section_len);

  644. #endif

  645. 

  646.     p_end = section + section_len - 4;

  647.     p = section;

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

  649.         return;

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

  651.         return;

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

  653.     if (onid < 0)

  654.         return;

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

  656.     if (val < 0)

  657.         return;

  658.     for(;;) {

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

  660.         if (sid < 0)

  661.             break;

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

  663.         if (val < 0)

  664.             break;

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

  666.         if (desc_list_len < 0)

  667.             break;

  668.         desc_list_end = p + desc_list_len;

  669.         if (desc_list_end > p_end)

  670.             break;

  671.         for(;;) {

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

  673.             if (desc_tag < 0)

  674.                 break;

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

  676.             desc_end = p + desc_len;

  677.             if (desc_end > desc_list_end)

  678.                 break;

  679. #ifdef DEBUG_SI

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

  681.                    desc_tag, desc_len);

  682. #endif

  683.             switch(desc_tag) {

  684.             case 0x48:

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

  686.                 if (service_type < 0)

  687.                     break;

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

  689.                 if (!provider_name)

  690.                     break;

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

  692.                 if (!name)

  693.                     break;

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

  695.                 break;

  696.             default:

  697.                 break;

  698.             }

  699.             p = desc_end;

  700.         }

  701.         p = desc_list_end;

  702.     }

  703. }

  704. 

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

  706. static void mpegts_scan_sdt(MpegTSContext *ts)

  707. {

  708.     mpegts_open_section_filter(ts, SDT_PID,

  709.                                                 sdt_cb, ts, 1);

  710. }

  711. 

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

  713.    than nothing !) */

  714. static void mpegts_scan_pat(MpegTSContext *ts)

  715. {

  716.     mpegts_open_section_filter(ts, PAT_PID,

  717.                                                 pat_scan_cb, ts, 1);

  718. }

  719. 

  720. /* TS stream handling */

  721. 

  722. enum MpegTSState {

  723.     MPEGTS_HEADER = 0,

  724.     MPEGTS_PESHEADER_FILL,

  725.     MPEGTS_PAYLOAD,

  726.     MPEGTS_SKIP,

  727. };

  728. 

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

  730. #define PES_START_SIZE 9

  731. #define MAX_PES_HEADER_SIZE (9 + 255)

  732. 

  733. struct PESContext {

  734.     int pid;

  735.     int stream_type;

  736.     MpegTSContext *ts;

  737.     AVFormatContext *stream;

  738.     AVStream *st;

  739.     enum MpegTSState state;

  740.     /* used to get the format */

  741.     int data_index;

  742.     int total_size;

  743.     int pes_header_size;

  744.     int64_t pts, dts;

  745.     uint8_t header[MAX_PES_HEADER_SIZE];

  746. };

  747. 

  748. static int64_t get_pts(const uint8_t *p)

  749. {

  750.     int64_t pts;

  751.     int val;

  752. 

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

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

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

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

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

  758.     return pts;

  759. }

  760. 

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

  762. static void mpegts_push_data(MpegTSFilter *filter,

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

  764. {

  765.     PESContext *pes = filter->u.pes_filter.opaque;

  766.     MpegTSContext *ts = pes->ts;

  767.     const uint8_t *p;

  768.     int len, code;

  769. 

  770.     if(!ts->pkt)

  771.         return;

  772. 

  773.     if (is_start) {

  774.         pes->state = MPEGTS_HEADER;

  775.         pes->data_index = 0;

  776.     }

  777.     p = buf;

  778.     while (buf_size > 0) {

  779.         switch(pes->state) {

  780.         case MPEGTS_HEADER:

  781.             len = PES_START_SIZE - pes->data_index;

  782.             if (len > buf_size)

  783.                 len = buf_size;

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

  785.             pes->data_index += len;

  786.             p += len;

  787.             buf_size -= len;

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

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

  790.                    decide */

  791. #if 0

  792.                 av_hex_dump_log(pes->stream, AV_LOG_DEBUG, pes->header, pes->data_index);

  793. #endif

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

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

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

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

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

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

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

  801.                         goto skip;

  802.                     if (!pes->st) {

  803.                         /* allocate stream */

  804.                         new_pes_av_stream(pes, code);

  805.                     }

  806.                     pes->state = MPEGTS_PESHEADER_FILL;

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

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

  809.                        unbounded */

  810.                     if (pes->total_size)

  811.                         pes->total_size += 6;

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

  813.                 } else {

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

  815.                     /* skip packet */

  816.                 skip:

  817.                     pes->state = MPEGTS_SKIP;

  818.                     continue;

  819.                 }

  820.             }

  821.             break;

  822.             /**********************************************/

  823.             /* PES packing parsing */

  824.         case MPEGTS_PESHEADER_FILL:

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

  826.             if (len > buf_size)

  827.                 len = buf_size;

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

  829.             pes->data_index += len;

  830.             p += len;

  831.             buf_size -= len;

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

  833.                 const uint8_t *r;

  834.                 unsigned int flags;

  835. 

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

  837.                 r = pes->header + 9;

  838.                 pes->pts = AV_NOPTS_VALUE;

  839.                 pes->dts = AV_NOPTS_VALUE;

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

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

  842.                     r += 5;

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

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

  845.                     r += 5;

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

  847.                     r += 5;

  848.                 }

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

  850.                 pes->state = MPEGTS_PAYLOAD;

  851.             }

  852.             break;

  853.         case MPEGTS_PAYLOAD:

  854.             if (pes->total_size) {

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

  856.                 if (len > buf_size)

  857.                     len = buf_size;

  858.             } else {

  859.                 len = buf_size;

  860.             }

  861.             if (len > 0) {

  862.                 AVPacket *pkt = ts->pkt;

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

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

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

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

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

  868.                     /* reset pts values */

  869.                     pes->pts = AV_NOPTS_VALUE;

  870.                     pes->dts = AV_NOPTS_VALUE;

  871.                     ts->stop_parse = 1;

  872.                     return;

  873.                 }

  874.             }

  875.             buf_size = 0;

  876.             break;

  877.         case MPEGTS_SKIP:

  878.             buf_size = 0;

  879.             break;

  880.         }

  881.     }

  882. }

  883. 

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

  885. {

  886.     AVStream *st;

  887.     int codec_type, codec_id;

  888. 

  889.     switch(pes->stream_type){

  890.     case STREAM_TYPE_AUDIO_MPEG1:

  891.     case STREAM_TYPE_AUDIO_MPEG2:

  892.         codec_type = CODEC_TYPE_AUDIO;

  893.         codec_id = CODEC_ID_MP3;

  894.         break;

  895.     case STREAM_TYPE_VIDEO_MPEG1:

  896.     case STREAM_TYPE_VIDEO_MPEG2:

  897.         codec_type = CODEC_TYPE_VIDEO;

  898.         codec_id = CODEC_ID_MPEG2VIDEO;

  899.         break;

  900.     case STREAM_TYPE_VIDEO_MPEG4:

  901.         codec_type = CODEC_TYPE_VIDEO;

  902.         codec_id = CODEC_ID_MPEG4;

  903.         break;

  904.     case STREAM_TYPE_VIDEO_H264:

  905.         codec_type = CODEC_TYPE_VIDEO;

  906.         codec_id = CODEC_ID_H264;

  907.         break;

  908.     case STREAM_TYPE_VIDEO_VC1:

  909.         codec_type = CODEC_TYPE_VIDEO;

  910.         codec_id = CODEC_ID_VC1;

  911.         break;

  912.     case STREAM_TYPE_AUDIO_AAC:

  913.         codec_type = CODEC_TYPE_AUDIO;

  914.         codec_id = CODEC_ID_AAC;

  915.         break;

  916.     case STREAM_TYPE_AUDIO_AC3:

  917.         codec_type = CODEC_TYPE_AUDIO;

  918.         codec_id = CODEC_ID_AC3;

  919.         break;

  920.     case STREAM_TYPE_AUDIO_DTS:

  921.         codec_type = CODEC_TYPE_AUDIO;

  922.         codec_id = CODEC_ID_DTS;

  923.         break;

  924.     case STREAM_TYPE_SUBTITLE_DVB:

  925.         codec_type = CODEC_TYPE_SUBTITLE;

  926.         codec_id = CODEC_ID_DVB_SUBTITLE;

  927.         break;

  928.     default:

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

  930.             codec_type = CODEC_TYPE_AUDIO;

  931.             codec_id = CODEC_ID_MP2;

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

  933.             codec_type = CODEC_TYPE_AUDIO;

  934.             codec_id = CODEC_ID_AC3;

  935.         } else {

  936.             codec_type = CODEC_TYPE_VIDEO;

  937.             codec_id = CODEC_ID_MPEG1VIDEO;

  938.         }

  939.         break;

  940.     }

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

  942.     if (st) {

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

  944.         st->priv_data = pes;

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

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

  947.         st->need_parsing = AVSTREAM_PARSE_FULL;

  948.         pes->st = st;

  949.     }

  950.     return st;

  951. }

  952. 

  953. 

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

  955. {

  956.     MpegTSFilter *tss;

  957.     PESContext *pes;

  958. 

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

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

  961.     if (!pes)

  962.         return 0;

  963.     pes->ts = ts;

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

  965.     pes->pid = pid;

  966.     pes->stream_type = stream_type;

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

  968.     if (!tss) {

  969.         av_free(pes);

  970.         return 0;

  971.     }

  972.     return pes;

  973. }

  974. 

  975. /* handle one TS packet */

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

  977. {

  978.     AVFormatContext *s = ts->stream;

  979.     MpegTSFilter *tss;

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

  981.     const uint8_t *p, *p_end;

  982. 

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

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

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

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

  987.         add_pes_stream(ts, pid, 0);

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

  989.     }

  990.     if (!tss)

  991.         return;

  992. 

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

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

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

  996.     tss->last_cc = cc;

  997. 

  998.     /* skip adaptation field */

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

  1000.     p = packet + 4;

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

  1002.         return;

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

  1004.         return;

  1005.     if (afc == 3) {

  1006.         /* skip adapation field */

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

  1008.     }

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

  1010.     p_end = packet + TS_PACKET_SIZE;

  1011.     if (p >= p_end)

  1012.         return;

  1013. 

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

  1015.         if (is_start) {

  1016.             /* pointer field present */

  1017.             len = *p++;

  1018.             if (p + len > p_end)

  1019.                 return;

  1020.             if (len && cc_ok) {

  1021.                 /* write remaining section bytes */

  1022.                 write_section_data(s, tss,

  1023.                                    p, len, 0);

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

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

  1026.                     return;

  1027.             }

  1028.             p += len;

  1029.             if (p < p_end) {

  1030.                 write_section_data(s, tss,

  1031.                                    p, p_end - p, 1);

  1032.             }

  1033.         } else {

  1034.             if (cc_ok) {

  1035.                 write_section_data(s, tss,

  1036.                                    p, p_end - p, 0);

  1037.             }

  1038.         }

  1039.     } else {

  1040.         tss->u.pes_filter.pes_cb(tss,

  1041.                                  p, p_end - p, is_start);

  1042.     }

  1043. }

  1044. 

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

  1046.    get_packet_size() ?) */

  1047. static int mpegts_resync(ByteIOContext *pb)

  1048. {

  1049.     int c, i;

  1050. 

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

  1052.         c = url_fgetc(pb);

  1053.         if (c < 0)

  1054.             return -1;

  1055.         if (c == 0x47) {

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

  1057.             return 0;

  1058.         }

  1059.     }

  1060.     /* no sync found */

  1061.     return -1;

  1062. }

  1063. 

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

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

  1066. {

  1067.     int skip, len;

  1068. 

  1069.     for(;;) {

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

  1071.         if (len != TS_PACKET_SIZE)

  1072.             return AVERROR_IO;

  1073.         /* check paquet sync byte */

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

  1075.             /* find a new packet start */

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

  1077.             if (mpegts_resync(pb) < 0)

  1078.                 return AVERROR_INVALIDDATA;

  1079.             else

  1080.                 continue;

  1081.         } else {

  1082.             skip = raw_packet_size - TS_PACKET_SIZE;

  1083.             if (skip > 0)

  1084.                 url_fskip(pb, skip);

  1085.             break;

  1086.         }

  1087.     }

  1088.     return 0;

  1089. }

  1090. 

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

  1092. {

  1093.     AVFormatContext *s = ts->stream;

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

  1095.     uint8_t packet[TS_PACKET_SIZE];

  1096.     int packet_num, ret;

  1097. 

  1098.     ts->stop_parse = 0;

  1099.     packet_num = 0;

  1100.     for(;;) {

  1101.         if (ts->stop_parse)

  1102.             break;

  1103.         packet_num++;

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

  1105.             break;

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

  1107.         if (ret != 0)

  1108.             return ret;

  1109.         handle_packet(ts, packet);

  1110.     }

  1111.     return 0;

  1112. }

  1113. 

  1114. static int mpegts_probe(AVProbeData *p)

  1115. {

  1116. #if 1

  1117.     const int size= p->buf_size;

  1118.     int score, fec_score, dvhs_score;

  1119. #define CHECK_COUNT 10

  1120. 

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

  1122.         return -1;

  1123. 

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

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

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

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

  1128. 

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

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

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

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

  1133.     else                                    return -1;

  1134. #else

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

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

  1137.         return AVPROBE_SCORE_MAX;

  1138.     else

  1139.         return 0;

  1140. #endif

  1141. }

  1142. 

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

  1144.    (-1) if not available */

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

  1146.                      const uint8_t *packet)

  1147. {

  1148.     int afc, len, flags;

  1149.     const uint8_t *p;

  1150.     unsigned int v;

  1151. 

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

  1153.     if (afc <= 1)

  1154.         return -1;

  1155.     p = packet + 4;

  1156.     len = p[0];

  1157.     p++;

  1158.     if (len == 0)

  1159.         return -1;

  1160.     flags = *p++;

  1161.     len--;

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

  1163.         return -1;

  1164.     if (len < 6)

  1165.         return -1;

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

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

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

  1169.     return 0;

  1170. }

  1171. 

  1172. static int mpegts_read_header(AVFormatContext *s,

  1173.                               AVFormatParameters *ap)

  1174. {

  1175.     MpegTSContext *ts = s->priv_data;

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

  1177.     uint8_t buf[1024];

  1178.     int len, sid, i;

  1179.     int64_t pos;

  1180.     MpegTSService *service;

  1181. 

  1182.     if (ap) {

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

  1184.         if(ap->mpeg2ts_raw){

  1185.             av_log(s, AV_LOG_ERROR, "use mpegtsraw_demuxer!\n");

  1186.             return -1;

  1187.         }

  1188.     }

  1189. 

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

  1191.     pos = url_ftell(pb);

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

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

  1194.         goto fail;

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

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

  1197.         goto fail;

  1198.     ts->stream = s;

  1199.     ts->auto_guess = 0;

  1200. 

  1201.     if (s->iformat == &mpegts_demuxer) {

  1202.         /* normal demux */

  1203. 

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

  1205.         url_fseek(pb, pos, SEEK_SET);

  1206.         mpegts_scan_sdt(ts);

  1207. 

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

  1209.             mpegts_scan_pat(ts);

  1210. 

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

  1212.         }

  1213. 

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

  1215.             /* raw transport stream */

  1216.             ts->auto_guess = 1;

  1217.             s->ctx_flags |= AVFMTCTX_NOHEADER;

  1218.             goto do_pcr;

  1219.         }

  1220. 

  1221.         /* tune to first service found */

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

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

  1224.             sid = service->sid;

  1225. #ifdef DEBUG_SI

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

  1227. #endif

  1228. 

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

  1230.             otherwise try to filter all PATs */

  1231. 

  1232.             url_fseek(pb, pos, SEEK_SET);

  1233.             mpegts_set_service(ts, sid);

  1234. 

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

  1236.         }

  1237.         /* if could not find service, enable auto_guess */

  1238. 

  1239.         ts->auto_guess = 1;

  1240. 

  1241. #ifdef DEBUG_SI

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

  1243. #endif

  1244.         s->ctx_flags |= AVFMTCTX_NOHEADER;

  1245.     } else {

  1246.         AVStream *st;

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

  1248.         int64_t pcrs[2], pcr_h;

  1249.         int packet_count[2];

  1250.         uint8_t packet[TS_PACKET_SIZE];

  1251. 

  1252.         /* only read packets */

  1253. 

  1254.     do_pcr:

  1255.         st = av_new_stream(s, 0);

  1256.         if (!st)

  1257.             goto fail;

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

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

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

  1261. 

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

  1263.         pcr_pid = -1;

  1264.         nb_pcrs = 0;

  1265.         nb_packets = 0;

  1266.         for(;;) {

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

  1268.             if (ret < 0)

  1269.                 return -1;

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

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

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

  1273.                 pcr_pid = pid;

  1274.                 packet_count[nb_pcrs] = nb_packets;

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

  1276.                 nb_pcrs++;

  1277.                 if (nb_pcrs >= 2)

  1278.                     break;

  1279.             }

  1280.             nb_packets++;

  1281.         }

  1282.         ts->pcr_pid = pcr_pid;

  1283. 

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

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

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

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

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

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

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

  1291. #if 0

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

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

  1294. #endif

  1295.     }

  1296. 

  1297.     url_fseek(pb, pos, SEEK_SET);

  1298.     return 0;

  1299.  fail:

  1300.     return -1;

  1301. }

  1302. 

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

  1304. 

  1305. static int mpegts_raw_read_packet(AVFormatContext *s,

  1306.                                   AVPacket *pkt)

  1307. {

  1308.     MpegTSContext *ts = s->priv_data;

  1309.     int ret, i;

  1310.     int64_t pcr_h, next_pcr_h, pos;

  1311.     int pcr_l, next_pcr_l;

  1312.     uint8_t pcr_buf[12];

  1313. 

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

  1315.         return AVERROR(ENOMEM);

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

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

  1318.     if (ret < 0) {

  1319.         av_free_packet(pkt);

  1320.         return ret;

  1321.     }

  1322.     if (ts->mpeg2ts_compute_pcr) {

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

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

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

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

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

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

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

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

  1331.                     /* XXX: not precise enough */

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

  1333.                         (i + 1);

  1334.                     break;

  1335.                 }

  1336.             }

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

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

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

  1340.         }

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

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

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

  1344.     }

  1345.     pkt->stream_index = 0;

  1346.     return 0;

  1347. }

  1348. 

  1349. static int mpegts_read_packet(AVFormatContext *s,

  1350.                               AVPacket *pkt)

  1351. {

  1352.     MpegTSContext *ts = s->priv_data;

  1353. 

  1354.     ts->pkt = pkt;

  1355.     return handle_packets(ts, 0);

  1356. }

  1357. 

  1358. static int mpegts_read_close(AVFormatContext *s)

  1359. {

  1360.     MpegTSContext *ts = s->priv_data;

  1361.     int i;

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

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

  1364. 

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

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

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

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

  1369.     }

  1370.     av_freep(&ts->services);

  1371. 

  1372.     return 0;

  1373. }

  1374. 

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

  1376.                               int64_t *ppos, int64_t pos_limit)

  1377. {

  1378.     MpegTSContext *ts = s->priv_data;

  1379.     int64_t pos, timestamp;

  1380.     uint8_t buf[TS_PACKET_SIZE];

  1381.     int pcr_l, pid;

  1382.     const int find_next= 1;

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

  1384.     if (find_next) {

  1385.         for(;;) {

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

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

  1388.                 return AV_NOPTS_VALUE;

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

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

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

  1392.                 break;

  1393.             }

  1394.             pos += ts->raw_packet_size;

  1395.         }

  1396.     } else {

  1397.         for(;;) {

  1398.             pos -= ts->raw_packet_size;

  1399.             if (pos < 0)

  1400.                 return AV_NOPTS_VALUE;

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

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

  1403.                 return AV_NOPTS_VALUE;

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

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

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

  1407.                 break;

  1408.             }

  1409.         }

  1410.     }

  1411.     *ppos = pos;

  1412. 

  1413.     return timestamp;

  1414. }

  1415. 

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

  1417.     MpegTSContext *ts = s->priv_data;

  1418.     uint8_t buf[TS_PACKET_SIZE];

  1419.     int64_t pos;

  1420. 

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

  1422.         return -1;

  1423. 

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

  1425. 

  1426.     for(;;) {

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

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

  1429.             return -1;

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

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

  1432.         pos += ts->raw_packet_size;

  1433.     }

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

  1435. 

  1436.     return 0;

  1437. }

  1438. 

  1439. /**************************************************************/

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

  1441. 

  1442. MpegTSContext *mpegts_parse_open(AVFormatContext *s)

  1443. {

  1444.     MpegTSContext *ts;

  1445. 

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

  1447.     if (!ts)

  1448.         return NULL;

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

  1450.     ts->raw_packet_size = TS_PACKET_SIZE;

  1451.     ts->stream = s;

  1452.     ts->auto_guess = 1;

  1453.     return ts;

  1454. }

  1455. 

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

  1457.    packet is output */

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

  1459.                         const uint8_t *buf, int len)

  1460. {

  1461.     int len1;

  1462. 

  1463.     len1 = len;

  1464.     ts->pkt = pkt;

  1465.     ts->stop_parse = 0;

  1466.     for(;;) {

  1467.         if (ts->stop_parse)

  1468.             break;

  1469.         if (len < TS_PACKET_SIZE)

  1470.             return -1;

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

  1472.             buf++;

  1473.             len--;

  1474.         } else {

  1475.             handle_packet(ts, buf);

  1476.             buf += TS_PACKET_SIZE;

  1477.             len -= TS_PACKET_SIZE;

  1478.         }

  1479.     }

  1480.     return len1 - len;

  1481. }

  1482. 

  1483. void mpegts_parse_close(MpegTSContext *ts)

  1484. {

  1485.     int i;

  1486. 

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

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

  1489.     av_free(ts);

  1490. }

  1491. 

  1492. AVInputFormat mpegts_demuxer = {

  1493.     "mpegts",

  1494.     "MPEG2 transport stream format",

  1495.     sizeof(MpegTSContext),

  1496.     mpegts_probe,

  1497.     mpegts_read_header,

  1498.     mpegts_read_packet,

  1499.     mpegts_read_close,

  1500.     read_seek,

  1501.     mpegts_get_pcr,

  1502.     .flags = AVFMT_SHOW_IDS,

  1503. };

  1504. 

  1505. AVInputFormat mpegtsraw_demuxer = {

  1506.     "mpegtsraw",

  1507.     "MPEG2 raw transport stream format",

  1508.     sizeof(MpegTSContext),

  1509.     mpegts_probe,

  1510.     mpegts_read_header,

  1511.     mpegts_raw_read_packet,

  1512.     mpegts_read_close,

  1513.     read_seek,

  1514.     mpegts_get_pcr,

  1515.     .flags = AVFMT_SHOW_IDS,

  1516. };