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

1586 lines
46KB
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. 

  22. //#define DEBUG

  23. //#define DEBUG_SEEK

  24. 

  25. #include "libavutil/crc.h"

  26. #include "libavutil/intreadwrite.h"

  27. #include "libavcodec/bytestream.h"

  28. #include "avformat.h"

  29. #include "mpegts.h"

  30. #include "internal.h"

  31. 

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

  33. #define MAX_SCAN_PACKETS 32000

  34. 

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

  36.    synchronisation is lost */

  37. #define MAX_RESYNC_SIZE 4096

  38. #define REGISTRATION_DESCRIPTOR 5

  39. 

  40. #define MAX_PES_PAYLOAD 200*1024

  41. 

  42. typedef struct PESContext PESContext;

  43. 

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

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

  46. 

  47. enum MpegTSFilterType {

  48.     MPEGTS_PES,

  49.     MPEGTS_SECTION,

  50. };

  51. 

  52. typedef struct MpegTSFilter MpegTSFilter;

  53. 

  54. typedef int PESCallback(MpegTSFilter *f, const uint8_t *buf, int len, int is_start, int64_t pos);

  55. 

  56. typedef struct MpegTSPESFilter {

  57.     PESCallback *pes_cb;

  58.     void *opaque;

  59. } MpegTSPESFilter;

  60. 

  61. typedef void SectionCallback(MpegTSFilter *f, const uint8_t *buf, int len);

  62. 

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

  64. 

  65. typedef struct MpegTSSectionFilter {

  66.     int section_index;

  67.     int section_h_size;

  68.     uint8_t *section_buf;

  69.     unsigned int check_crc:1;

  70.     unsigned int end_of_section_reached:1;

  71.     SectionCallback *section_cb;

  72.     void *opaque;

  73. } MpegTSSectionFilter;

  74. 

  75. struct MpegTSFilter {

  76.     int pid;

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

  78.     enum MpegTSFilterType type;

  79.     union {

  80.         MpegTSPESFilter pes_filter;

  81.         MpegTSSectionFilter section_filter;

  82.     } u;

  83. };

  84. 

  85. #define MAX_PIDS_PER_PROGRAM 64

  86. struct Program {

  87.     unsigned int id; //program id/service id

  88.     unsigned int nb_pids;

  89.     unsigned int pids[MAX_PIDS_PER_PROGRAM];

  90. };

  91. 

  92. struct MpegTSContext {

  93.     /* user data */

  94.     AVFormatContext *stream;

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

  96.     int raw_packet_size;

  97. 

  98.     int pos47;

  99. 

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

  101.     int auto_guess;

  102. 

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

  104.     int mpeg2ts_compute_pcr;

  105. 

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

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

  108. 

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

  110.     /** stop parsing loop                                    */

  111.     int stop_parse;

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

  113.     AVPacket *pkt;

  114.     /** to detect seek                                       */

  115.     int64_t last_pos;

  116. 

  117.     /******************************************/

  118.     /* private mpegts data */

  119.     /* scan context */

  120.     /** structure to keep track of Program->pids mapping     */

  121.     unsigned int nb_prg;

  122.     struct Program *prg;

  123. 

  124. 

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

  126.     MpegTSFilter *pids[NB_PID_MAX];

  127. };

  128. 

  129. /* TS stream handling */

  130. 

  131. enum MpegTSState {

  132.     MPEGTS_HEADER = 0,

  133.     MPEGTS_PESHEADER_FILL,

  134.     MPEGTS_PAYLOAD,

  135.     MPEGTS_SKIP,

  136. };

  137. 

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

  139. #define PES_START_SIZE 9

  140. #define MAX_PES_HEADER_SIZE (9 + 255)

  141. 

  142. struct PESContext {

  143.     int pid;

  144.     int pcr_pid; /**< if -1 then all packets containing PCR are considered */

  145.     int stream_type;

  146.     MpegTSContext *ts;

  147.     AVFormatContext *stream;

  148.     AVStream *st;

  149.     enum MpegTSState state;

  150.     /* used to get the format */

  151.     int data_index;

  152.     int total_size;

  153.     int pes_header_size;

  154.     int64_t pts, dts;

  155.     int64_t ts_packet_pos; /**< position of first TS packet of this PES packet */

  156.     uint8_t header[MAX_PES_HEADER_SIZE];

  157.     uint8_t *buffer;

  158. };

  159. 

  160. extern AVInputFormat mpegts_demuxer;

  161. 

  162. static void clear_program(MpegTSContext *ts, unsigned int programid)

  163. {

  164.     int i;

  165. 

  166.     for(i=0; i<ts->nb_prg; i++)

  167.         if(ts->prg[i].id == programid)

  168.             ts->prg[i].nb_pids = 0;

  169. }

  170. 

  171. static void clear_programs(MpegTSContext *ts)

  172. {

  173.     av_freep(&ts->prg);

  174.     ts->nb_prg=0;

  175. }

  176. 

  177. static void add_pat_entry(MpegTSContext *ts, unsigned int programid)

  178. {

  179.     struct Program *p;

  180.     void *tmp = av_realloc(ts->prg, (ts->nb_prg+1)*sizeof(struct Program));

  181.     if(!tmp)

  182.         return;

  183.     ts->prg = tmp;

  184.     p = &ts->prg[ts->nb_prg];

  185.     p->id = programid;

  186.     p->nb_pids = 0;

  187.     ts->nb_prg++;

  188. }

  189. 

  190. static void add_pid_to_pmt(MpegTSContext *ts, unsigned int programid, unsigned int pid)

  191. {

  192.     int i;

  193.     struct Program *p = NULL;

  194.     for(i=0; i<ts->nb_prg; i++) {

  195.         if(ts->prg[i].id == programid) {

  196.             p = &ts->prg[i];

  197.             break;

  198.         }

  199.     }

  200.     if(!p)

  201.         return;

  202. 

  203.     if(p->nb_pids >= MAX_PIDS_PER_PROGRAM)

  204.         return;

  205.     p->pids[p->nb_pids++] = pid;

  206. }

  207. 

  208. /**

  209.  * \brief discard_pid() decides if the pid is to be discarded according

  210.  *                      to caller's programs selection

  211.  * \param ts    : - TS context

  212.  * \param pid   : - pid

  213.  * \return 1 if the pid is only comprised in programs that have .discard=AVDISCARD_ALL

  214.  *         0 otherwise

  215.  */

  216. static int discard_pid(MpegTSContext *ts, unsigned int pid)

  217. {

  218.     int i, j, k;

  219.     int used = 0, discarded = 0;

  220.     struct Program *p;

  221.     for(i=0; i<ts->nb_prg; i++) {

  222.         p = &ts->prg[i];

  223.         for(j=0; j<p->nb_pids; j++) {

  224.             if(p->pids[j] != pid)

  225.                 continue;

  226.             //is program with id p->id set to be discarded?

  227.             for(k=0; k<ts->stream->nb_programs; k++) {

  228.                 if(ts->stream->programs[k]->id == p->id) {

  229.                     if(ts->stream->programs[k]->discard == AVDISCARD_ALL)

  230.                         discarded++;

  231.                     else

  232.                         used++;

  233.                 }

  234.             }

  235.         }

  236.     }

  237. 

  238.     return !used && discarded;

  239. }

  240. 

  241. /**

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

  243.  *  function when they are complete.

  244.  */

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

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

  247. {

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

  249.     int len;

  250. 

  251.     if (is_start) {

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

  253.         tss->section_index = buf_size;

  254.         tss->section_h_size = -1;

  255.         tss->end_of_section_reached = 0;

  256.     } else {

  257.         if (tss->end_of_section_reached)

  258.             return;

  259.         len = 4096 - tss->section_index;

  260.         if (buf_size < len)

  261.             len = buf_size;

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

  263.         tss->section_index += len;

  264.     }

  265. 

  266.     /* compute section length if possible */

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

  268.         len = (AV_RB16(tss->section_buf + 1) & 0xfff) + 3;

  269.         if (len > 4096)

  270.             return;

  271.         tss->section_h_size = len;

  272.     }

  273. 

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

  275.         tss->end_of_section_reached = 1;

  276.         if (!tss->check_crc ||

  277.             av_crc(av_crc_get_table(AV_CRC_32_IEEE), -1,

  278.                    tss->section_buf, tss->section_h_size) == 0)

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

  280.     }

  281. }

  282. 

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

  284.                                          SectionCallback *section_cb, void *opaque,

  285.                                          int check_crc)

  286. 

  287. {

  288.     MpegTSFilter *filter;

  289.     MpegTSSectionFilter *sec;

  290. 

  291.     dprintf(ts->stream, "Filter: pid=0x%x\n", pid);

  292. 

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

  294.         return NULL;

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

  296.     if (!filter)

  297.         return NULL;

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

  299.     filter->type = MPEGTS_SECTION;

  300.     filter->pid = pid;

  301.     filter->last_cc = -1;

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

  303.     sec->section_cb = section_cb;

  304.     sec->opaque = opaque;

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

  306.     sec->check_crc = check_crc;

  307.     if (!sec->section_buf) {

  308.         av_free(filter);

  309.         return NULL;

  310.     }

  311.     return filter;

  312. }

  313. 

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

  315.                                      PESCallback *pes_cb,

  316.                                      void *opaque)

  317. {

  318.     MpegTSFilter *filter;

  319.     MpegTSPESFilter *pes;

  320. 

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

  322.         return NULL;

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

  324.     if (!filter)

  325.         return NULL;

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

  327.     filter->type = MPEGTS_PES;

  328.     filter->pid = pid;

  329.     filter->last_cc = -1;

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

  331.     pes->pes_cb = pes_cb;

  332.     pes->opaque = opaque;

  333.     return filter;

  334. }

  335. 

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

  337. {

  338.     int pid;

  339. 

  340.     pid = filter->pid;

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

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

  343.     else if (filter->type == MPEGTS_PES) {

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

  345.         av_freep(&pes->buffer);

  346.         /* referenced private data will be freed later in

  347.          * av_close_input_stream */

  348.         if (!((PESContext *)filter->u.pes_filter.opaque)->st) {

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

  350.         }

  351.     }

  352. 

  353.     av_free(filter);

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

  355. }

  356. 

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

  358.     int stat[packet_size];

  359.     int i;

  360.     int x=0;

  361.     int best_score=0;

  362. 

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

  364. 

  365.     for(x=i=0; i<size-3; i++){

  366.         if(buf[i] == 0x47 && !(buf[i+1] & 0x80) && (buf[i+3] & 0x30)){

  367.             stat[x]++;

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

  369.                 best_score= stat[x];

  370.                 if(index) *index= x;

  371.             }

  372.         }

  373. 

  374.         x++;

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

  376.     }

  377. 

  378.     return best_score;

  379. }

  380. 

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

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

  383. {

  384.     int score, fec_score, dvhs_score;

  385. 

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

  387.         return -1;

  388. 

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

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

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

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

  393. 

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

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

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

  397.     else                       return -1;

  398. }

  399. 

  400. typedef struct SectionHeader {

  401.     uint8_t tid;

  402.     uint16_t id;

  403.     uint8_t version;

  404.     uint8_t sec_num;

  405.     uint8_t last_sec_num;

  406. } SectionHeader;

  407. 

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

  409. {

  410.     const uint8_t *p;

  411.     int c;

  412. 

  413.     p = *pp;

  414.     if (p >= p_end)

  415.         return -1;

  416.     c = *p++;

  417.     *pp = p;

  418.     return c;

  419. }

  420. 

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

  422. {

  423.     const uint8_t *p;

  424.     int c;

  425. 

  426.     p = *pp;

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

  428.         return -1;

  429.     c = AV_RB16(p);

  430.     p += 2;

  431.     *pp = p;

  432.     return c;

  433. }

  434. 

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

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

  437. {

  438.     int len;

  439.     const uint8_t *p;

  440.     char *str;

  441. 

  442.     p = *pp;

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

  444.     if (len < 0)

  445.         return NULL;

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

  447.         return NULL;

  448.     str = av_malloc(len + 1);

  449.     if (!str)

  450.         return NULL;

  451.     memcpy(str, p, len);

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

  453.     p += len;

  454.     *pp = p;

  455.     return str;

  456. }

  457. 

  458. static int parse_section_header(SectionHeader *h,

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

  460. {

  461.     int val;

  462. 

  463.     val = get8(pp, p_end);

  464.     if (val < 0)

  465.         return -1;

  466.     h->tid = val;

  467.     *pp += 2;

  468.     val = get16(pp, p_end);

  469.     if (val < 0)

  470.         return -1;

  471.     h->id = val;

  472.     val = get8(pp, p_end);

  473.     if (val < 0)

  474.         return -1;

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

  476.     val = get8(pp, p_end);

  477.     if (val < 0)

  478.         return -1;

  479.     h->sec_num = val;

  480.     val = get8(pp, p_end);

  481.     if (val < 0)

  482.         return -1;

  483.     h->last_sec_num = val;

  484.     return 0;

  485. }

  486. 

  487. 

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

  489. {

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

  491.     SectionHeader h1, *h = &h1;

  492.     PESContext *pes;

  493.     AVStream *st;

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

  495.     int program_info_length, pcr_pid, pid, stream_type;

  496.     int desc_list_len, desc_len, desc_tag;

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

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

  499.     int has_hdmv_descr = 0;

  500.     int has_dirac_descr = 0;

  501.     uint32_t reg_desc = 0; /* registration descriptor */

  502. 

  503. #ifdef DEBUG

  504.     dprintf(ts->stream, "PMT: len %i\n", section_len);

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

  506. #endif

  507. 

  508.     p_end = section + section_len - 4;

  509.     p = section;

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

  511.         return;

  512. 

  513.     dprintf(ts->stream, "sid=0x%x sec_num=%d/%d\n",

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

  515. 

  516.     if (h->tid != PMT_TID)

  517.         return;

  518. 

  519.     clear_program(ts, h->id);

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

  521.     if (pcr_pid < 0)

  522.         return;

  523.     add_pid_to_pmt(ts, h->id, pcr_pid);

  524. 

  525.     dprintf(ts->stream, "pcr_pid=0x%x\n", pcr_pid);

  526. 

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

  528.     if (program_info_length < 0)

  529.         return;

  530.     while(program_info_length >= 2) {

  531.         uint8_t tag, len;

  532.         tag = get8(&p, p_end);

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

  534.         if(len > program_info_length - 2)

  535.             //something else is broken, exit the program_descriptors_loop

  536.             break;

  537.         program_info_length -= len + 2;

  538.         if(tag == REGISTRATION_DESCRIPTOR && len >= 4) {

  539.             reg_desc = bytestream_get_le32(&p);

  540.             len -= 4;

  541.             if(reg_desc == AV_RL32("HDMV"))

  542.                 has_hdmv_descr = 1;

  543.         }

  544.         p += len;

  545.     }

  546.     p += program_info_length;

  547.     if (p >= p_end)

  548.         return;

  549.     for(;;) {

  550.         language[0] = 0;

  551.         st = 0;

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

  553.         if (stream_type < 0)

  554.             break;

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

  556.         if (pid < 0)

  557.             break;

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

  559.         if (desc_list_len < 0)

  560.             break;

  561.         desc_list_end = p + desc_list_len;

  562.         if (desc_list_end > p_end)

  563.             break;

  564.         for(;;) {

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

  566.             if (desc_tag < 0)

  567.                 break;

  568.             if (stream_type == STREAM_TYPE_PRIVATE_DATA) {

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

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

  571.                     stream_type = STREAM_TYPE_AUDIO_AC3;

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

  573.                     /* DVB DTS audio */

  574.                     stream_type = STREAM_TYPE_AUDIO_DTS;

  575.                 }

  576.             }

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

  578.             if (desc_len < 0)

  579.                 break;

  580.             desc_end = p + desc_len;

  581.             if (desc_end > desc_list_end)

  582.                 break;

  583. 

  584.             dprintf(ts->stream, "tag: 0x%02x len=%d\n",

  585.                    desc_tag, desc_len);

  586. 

  587.             switch(desc_tag) {

  588.             case DVB_SUBT_DESCID:

  589.                 if (stream_type == STREAM_TYPE_PRIVATE_DATA)

  590.                     stream_type = STREAM_TYPE_SUBTITLE_DVB;

  591. 

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

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

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

  595.                 language[3] = 0;

  596.                 get8(&p, desc_end);

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

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

  599. 

  600.                 break;

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

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

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

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

  605.                 language[3] = 0;

  606.                 break;

  607.             case REGISTRATION_DESCRIPTOR: /*MPEG-2 Registration descriptor */

  608.                 reg_desc = bytestream_get_le32(&p);

  609.                 if(reg_desc == AV_RL32("drac"))

  610.                     has_dirac_descr = 1;

  611.                 else if(reg_desc == AV_RL32("AC-3"))

  612.                     stream_type = STREAM_TYPE_AUDIO_AC3;

  613.                 break;

  614.             default:

  615.                 break;

  616.             }

  617.             p = desc_end;

  618.         }

  619.         p = desc_list_end;

  620. 

  621.         dprintf(ts->stream, "stream_type=%x pid=0x%x\n",

  622.                stream_type, pid);

  623. 

  624.         /* now create ffmpeg stream */

  625.             if(ts->pids[pid] && ts->pids[pid]->type == MPEGTS_PES){

  626.                 pes= ts->pids[pid]->u.pes_filter.opaque;

  627.                 st= pes->st;

  628.             }else{

  629.                 if (ts->pids[pid]) mpegts_close_filter(ts, ts->pids[pid]); //wrongly added sdt filter probably

  630.                 pes = add_pes_stream(ts, pid, pcr_pid, stream_type);

  631.                 if (pes)

  632.                     st = new_pes_av_stream(pes, 0);

  633.             }

  634.             add_pid_to_pmt(ts, h->id, pid);

  635.             if(st)

  636.                 av_program_add_stream_index(ts->stream, h->id, st->index);

  637. 

  638.         if (st) {

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

  640.                 av_metadata_set(&st->metadata, "language", language);

  641.             }

  642. 

  643.             if (stream_type == STREAM_TYPE_SUBTITLE_DVB) {

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

  645.             }

  646.         }

  647.     }

  648.     /* all parameters are there */

  649.     ts->stop_parse++;

  650.     mpegts_close_filter(ts, filter);

  651. }

  652. 

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

  654. {

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

  656.     SectionHeader h1, *h = &h1;

  657.     const uint8_t *p, *p_end;

  658.     int sid, pmt_pid;

  659. 

  660. #ifdef DEBUG

  661.     dprintf(ts->stream, "PAT:\n");

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

  663. #endif

  664.     p_end = section + section_len - 4;

  665.     p = section;

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

  667.         return;

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

  669.         return;

  670. 

  671.     clear_programs(ts);

  672.     for(;;) {

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

  674.         if (sid < 0)

  675.             break;

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

  677.         if (pmt_pid < 0)

  678.             break;

  679. 

  680.         dprintf(ts->stream, "sid=0x%x pid=0x%x\n", sid, pmt_pid);

  681. 

  682.         if (sid == 0x0000) {

  683.             /* NIT info */

  684.         } else {

  685.             av_new_program(ts->stream, sid);

  686.             ts->stop_parse--;

  687.             mpegts_open_section_filter(ts, pmt_pid, pmt_cb, ts, 1);

  688.             add_pat_entry(ts, sid);

  689.             add_pid_to_pmt(ts, sid, 0); //add pat pid to program

  690.             add_pid_to_pmt(ts, sid, pmt_pid);

  691.         }

  692.     }

  693.     /* not found */

  694.     ts->stop_parse++;

  695. 

  696.     mpegts_close_filter(ts, filter);

  697. }

  698. 

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

  700. {

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

  702.     SectionHeader h1, *h = &h1;

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

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

  705.     char *name, *provider_name;

  706. 

  707. #ifdef DEBUG

  708.     dprintf(ts->stream, "SDT:\n");

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

  710. #endif

  711. 

  712.     p_end = section + section_len - 4;

  713.     p = section;

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

  715.         return;

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

  717.         return;

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

  719.     if (onid < 0)

  720.         return;

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

  722.     if (val < 0)

  723.         return;

  724.     for(;;) {

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

  726.         if (sid < 0)

  727.             break;

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

  729.         if (val < 0)

  730.             break;

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

  732.         if (desc_list_len < 0)

  733.             break;

  734.         desc_list_end = p + desc_list_len;

  735.         if (desc_list_end > p_end)

  736.             break;

  737.         for(;;) {

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

  739.             if (desc_tag < 0)

  740.                 break;

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

  742.             desc_end = p + desc_len;

  743.             if (desc_end > desc_list_end)

  744.                 break;

  745. 

  746.             dprintf(ts->stream, "tag: 0x%02x len=%d\n",

  747.                    desc_tag, desc_len);

  748. 

  749.             switch(desc_tag) {

  750.             case 0x48:

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

  752.                 if (service_type < 0)

  753.                     break;

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

  755.                 if (!provider_name)

  756.                     break;

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

  758.                 if (name) {

  759.                     AVProgram *program = av_new_program(ts->stream, sid);

  760.                     if(program) {

  761.                         av_metadata_set(&program->metadata, "name", name);

  762.                         av_metadata_set(&program->metadata, "provider_name", provider_name);

  763.                     }

  764.                 }

  765.                 av_free(name);

  766.                 av_free(provider_name);

  767.                 break;

  768.             default:

  769.                 break;

  770.             }

  771.             p = desc_end;

  772.         }

  773.         p = desc_list_end;

  774.     }

  775. }

  776. 

  777. static int64_t get_pts(const uint8_t *p)

  778. {

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

  780.     pts |= (AV_RB16(p + 1) >> 1) << 15;

  781.     pts |=  AV_RB16(p + 3) >> 1;

  782.     return pts;

  783. }

  784. 

  785. static void new_pes_packet(PESContext *pes, AVPacket *pkt)

  786. {

  787.     av_init_packet(pkt);

  788. 

  789.     pkt->destruct = av_destruct_packet;

  790.     pkt->data = pes->buffer;

  791.     pkt->size = pes->data_index;

  792.     memset(pkt->data+pkt->size, 0, FF_INPUT_BUFFER_PADDING_SIZE);

  793. 

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

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

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

  797.     /* store position of first TS packet of this PES packet */

  798.     pkt->pos = pes->ts_packet_pos;

  799. 

  800.     /* reset pts values */

  801.     pes->pts = AV_NOPTS_VALUE;

  802.     pes->dts = AV_NOPTS_VALUE;

  803.     pes->buffer = NULL;

  804.     pes->data_index = 0;

  805. }

  806. 

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

  808. static int mpegts_push_data(MpegTSFilter *filter,

  809.                             const uint8_t *buf, int buf_size, int is_start,

  810.                             int64_t pos)

  811. {

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

  813.     MpegTSContext *ts = pes->ts;

  814.     const uint8_t *p;

  815.     int len, code;

  816. 

  817.     if(!ts->pkt)

  818.         return 0;

  819. 

  820.     if (is_start) {

  821.         if (pes->state == MPEGTS_PAYLOAD && pes->data_index > 0) {

  822.             new_pes_packet(pes, ts->pkt);

  823.             ts->stop_parse = 1;

  824.         }

  825.         pes->state = MPEGTS_HEADER;

  826.         pes->data_index = 0;

  827.         pes->ts_packet_pos = pos;

  828.     }

  829.     p = buf;

  830.     while (buf_size > 0) {

  831.         switch(pes->state) {

  832.         case MPEGTS_HEADER:

  833.             len = PES_START_SIZE - pes->data_index;

  834.             if (len > buf_size)

  835.                 len = buf_size;

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

  837.             pes->data_index += len;

  838.             p += len;

  839.             buf_size -= len;

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

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

  842.                    decide */

  843. #if 0

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

  845. #endif

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

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

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

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

  850.                     if (!pes->st || pes->st->discard == AVDISCARD_ALL ||

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

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

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

  854.                         goto skip;

  855.                     pes->state = MPEGTS_PESHEADER_FILL;

  856.                     pes->total_size = AV_RB16(pes->header + 4);

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

  858.                        unbounded */

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

  860.                 } else {

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

  862.                     /* skip packet */

  863.                 skip:

  864.                     pes->state = MPEGTS_SKIP;

  865.                     continue;

  866.                 }

  867.             }

  868.             break;

  869.             /**********************************************/

  870.             /* PES packing parsing */

  871.         case MPEGTS_PESHEADER_FILL:

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

  873.             if (len < 0)

  874.                 return -1;

  875.             if (len > buf_size)

  876.                 len = buf_size;

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

  878.             pes->data_index += len;

  879.             p += len;

  880.             buf_size -= len;

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

  882.                 const uint8_t *r;

  883.                 unsigned int flags;

  884. 

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

  886.                 r = pes->header + 9;

  887.                 pes->pts = AV_NOPTS_VALUE;

  888.                 pes->dts = AV_NOPTS_VALUE;

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

  890.                     pes->dts = pes->pts = get_pts(r);

  891.                     r += 5;

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

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

  894.                     r += 5;

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

  896.                     r += 5;

  897.                 }

  898. 

  899.                 if (pes->total_size > pes->data_index - 6)

  900.                     pes->total_size -= pes->data_index - 6;

  901.                 else

  902.                     pes->total_size = MAX_PES_PAYLOAD;

  903.                 /* allocate pes buffer */

  904.                 pes->buffer = av_malloc(pes->total_size+FF_INPUT_BUFFER_PADDING_SIZE);

  905.                 if (!pes->buffer)

  906.                     return AVERROR(ENOMEM);

  907. 

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

  909.                 pes->state = MPEGTS_PAYLOAD;

  910.                 pes->data_index = 0;

  911.             }

  912.             break;

  913.         case MPEGTS_PAYLOAD:

  914.             if (buf_size > 0) {

  915.                 if (pes->data_index+buf_size > pes->total_size) {

  916.                     new_pes_packet(pes, ts->pkt);

  917.                     pes->total_size = MAX_PES_PAYLOAD;

  918.                     pes->buffer = av_malloc(pes->total_size+FF_INPUT_BUFFER_PADDING_SIZE);

  919.                     if (!pes->buffer)

  920.                         return AVERROR(ENOMEM);

  921.                     ts->stop_parse = 1;

  922.                 }

  923.                 memcpy(pes->buffer+pes->data_index, p, buf_size);

  924.                 pes->data_index += buf_size;

  925.             }

  926.             buf_size = 0;

  927.             break;

  928.         case MPEGTS_SKIP:

  929.             buf_size = 0;

  930.             break;

  931.         }

  932.     }

  933. 

  934.     return 0;

  935. }

  936. 

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

  938. {

  939.     AVStream *st;

  940.     enum CodecID codec_id;

  941.     enum CodecType codec_type;

  942. 

  943.     switch(pes->stream_type){

  944.     case STREAM_TYPE_AUDIO_MPEG1:

  945.     case STREAM_TYPE_AUDIO_MPEG2:

  946.         codec_type = CODEC_TYPE_AUDIO;

  947.         codec_id = CODEC_ID_MP3;

  948.         break;

  949.     case STREAM_TYPE_VIDEO_MPEG1:

  950.     case STREAM_TYPE_VIDEO_MPEG2:

  951.         codec_type = CODEC_TYPE_VIDEO;

  952.         codec_id = CODEC_ID_MPEG2VIDEO;

  953.         break;

  954.     case STREAM_TYPE_VIDEO_MPEG4:

  955.         codec_type = CODEC_TYPE_VIDEO;

  956.         codec_id = CODEC_ID_MPEG4;

  957.         break;

  958.     case STREAM_TYPE_VIDEO_H264:

  959.         codec_type = CODEC_TYPE_VIDEO;

  960.         codec_id = CODEC_ID_H264;

  961.         break;

  962.     case STREAM_TYPE_VIDEO_VC1:

  963.         codec_type = CODEC_TYPE_VIDEO;

  964.         codec_id = CODEC_ID_VC1;

  965.         break;

  966.     case STREAM_TYPE_VIDEO_DIRAC:

  967.         codec_type = CODEC_TYPE_VIDEO;

  968.         codec_id = CODEC_ID_DIRAC;

  969.         break;

  970.     case STREAM_TYPE_AUDIO_AAC:

  971.         codec_type = CODEC_TYPE_AUDIO;

  972.         codec_id = CODEC_ID_AAC;

  973.         break;

  974.     case STREAM_TYPE_AUDIO_AC3:

  975.         codec_type = CODEC_TYPE_AUDIO;

  976.         codec_id = CODEC_ID_AC3;

  977.         break;

  978.     case STREAM_TYPE_AUDIO_DTS:

  979.     case STREAM_TYPE_AUDIO_HDMV_DTS:

  980.         codec_type = CODEC_TYPE_AUDIO;

  981.         codec_id = CODEC_ID_DTS;

  982.         break;

  983.     case STREAM_TYPE_SUBTITLE_DVB:

  984.         codec_type = CODEC_TYPE_SUBTITLE;

  985.         codec_id = CODEC_ID_DVB_SUBTITLE;

  986.         break;

  987.     default:

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

  989.             codec_type = CODEC_TYPE_AUDIO;

  990.             codec_id = CODEC_ID_MP2;

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

  992.             codec_type = CODEC_TYPE_AUDIO;

  993.             codec_id = CODEC_ID_AC3;

  994.         } else {

  995.             codec_type = CODEC_TYPE_DATA;

  996.             codec_id = CODEC_ID_PROBE;

  997.         }

  998.         break;

  999.     }

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

  1001.     if (st) {

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

  1003.         st->priv_data = pes;

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

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

  1006.         st->need_parsing = AVSTREAM_PARSE_FULL;

  1007.         pes->st = st;

  1008.     }

  1009.     return st;

  1010. }

  1011. 

  1012. 

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

  1014. {

  1015.     MpegTSFilter *tss;

  1016.     PESContext *pes;

  1017. 

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

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

  1020.     if (!pes)

  1021.         return 0;

  1022.     pes->ts = ts;

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

  1024.     pes->pid = pid;

  1025.     pes->pcr_pid = pcr_pid;

  1026.     pes->stream_type = stream_type;

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

  1028.     if (!tss) {

  1029.         av_free(pes);

  1030.         return 0;

  1031.     }

  1032.     return pes;

  1033. }

  1034. 

  1035. /* handle one TS packet */

  1036. static int handle_packet(MpegTSContext *ts, const uint8_t *packet)

  1037. {

  1038.     AVFormatContext *s = ts->stream;

  1039.     MpegTSFilter *tss;

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

  1041.     const uint8_t *p, *p_end;

  1042.     int64_t pos;

  1043. 

  1044.     pid = AV_RB16(packet + 1) & 0x1fff;

  1045.     if(pid && discard_pid(ts, pid))

  1046.         return 0;

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

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

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

  1050.         add_pes_stream(ts, pid, -1, 0);

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

  1052.     }

  1053.     if (!tss)

  1054.         return 0;

  1055. 

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

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

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

  1059.     tss->last_cc = cc;

  1060. 

  1061.     /* skip adaptation field */

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

  1063.     p = packet + 4;

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

  1065.         return 0;

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

  1067.         return 0;

  1068.     if (afc == 3) {

  1069.         /* skip adapation field */

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

  1071.     }

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

  1073.     p_end = packet + TS_PACKET_SIZE;

  1074.     if (p >= p_end)

  1075.         return 0;

  1076. 

  1077.     pos = url_ftell(ts->stream->pb);

  1078.     ts->pos47= pos % ts->raw_packet_size;

  1079. 

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

  1081.         if (is_start) {

  1082.             /* pointer field present */

  1083.             len = *p++;

  1084.             if (p + len > p_end)

  1085.                 return 0;

  1086.             if (len && cc_ok) {

  1087.                 /* write remaining section bytes */

  1088.                 write_section_data(s, tss,

  1089.                                    p, len, 0);

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

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

  1092.                     return 0;

  1093.             }

  1094.             p += len;

  1095.             if (p < p_end) {

  1096.                 write_section_data(s, tss,

  1097.                                    p, p_end - p, 1);

  1098.             }

  1099.         } else {

  1100.             if (cc_ok) {

  1101.                 write_section_data(s, tss,

  1102.                                    p, p_end - p, 0);

  1103.             }

  1104.         }

  1105.     } else {

  1106.         int ret;

  1107.         // Note: The position here points actually behind the current packet.

  1108.         if ((ret = tss->u.pes_filter.pes_cb(tss, p, p_end - p, is_start,

  1109.                                             pos - ts->raw_packet_size)) < 0)

  1110.             return ret;

  1111.     }

  1112. 

  1113.     return 0;

  1114. }

  1115. 

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

  1117.    get_packet_size() ?) */

  1118. static int mpegts_resync(ByteIOContext *pb)

  1119. {

  1120.     int c, i;

  1121. 

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

  1123.         c = url_fgetc(pb);

  1124.         if (c < 0)

  1125.             return -1;

  1126.         if (c == 0x47) {

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

  1128.             return 0;

  1129.         }

  1130.     }

  1131.     /* no sync found */

  1132.     return -1;

  1133. }

  1134. 

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

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

  1137. {

  1138.     int skip, len;

  1139. 

  1140.     for(;;) {

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

  1142.         if (len != TS_PACKET_SIZE)

  1143.             return AVERROR(EIO);

  1144.         /* check paquet sync byte */

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

  1146.             /* find a new packet start */

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

  1148.             if (mpegts_resync(pb) < 0)

  1149.                 return AVERROR_INVALIDDATA;

  1150.             else

  1151.                 continue;

  1152.         } else {

  1153.             skip = raw_packet_size - TS_PACKET_SIZE;

  1154.             if (skip > 0)

  1155.                 url_fskip(pb, skip);

  1156.             break;

  1157.         }

  1158.     }

  1159.     return 0;

  1160. }

  1161. 

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

  1163. {

  1164.     AVFormatContext *s = ts->stream;

  1165.     ByteIOContext *pb = s->pb;

  1166.     uint8_t packet[TS_PACKET_SIZE];

  1167.     int packet_num, ret;

  1168. 

  1169.     ts->stop_parse = 0;

  1170.     packet_num = 0;

  1171.     for(;;) {

  1172.         if (ts->stop_parse>0)

  1173.             break;

  1174.         packet_num++;

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

  1176.             break;

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

  1178.         if (ret != 0)

  1179.             return ret;

  1180.         ret = handle_packet(ts, packet);

  1181.         if (ret != 0)

  1182.             return ret;

  1183.     }

  1184.     return 0;

  1185. }

  1186. 

  1187. static int mpegts_probe(AVProbeData *p)

  1188. {

  1189. #if 1

  1190.     const int size= p->buf_size;

  1191.     int score, fec_score, dvhs_score;

  1192.     int check_count= size / TS_FEC_PACKET_SIZE;

  1193. #define CHECK_COUNT 10

  1194. 

  1195.     if (check_count < CHECK_COUNT)

  1196.         return -1;

  1197. 

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

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

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

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

  1202. 

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

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

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

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

  1207.     else                                    return -1;

  1208. #else

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

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

  1211.         return AVPROBE_SCORE_MAX;

  1212.     else

  1213.         return 0;

  1214. #endif

  1215. }

  1216. 

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

  1218.    (-1) if not available */

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

  1220.                      const uint8_t *packet)

  1221. {

  1222.     int afc, len, flags;

  1223.     const uint8_t *p;

  1224.     unsigned int v;

  1225. 

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

  1227.     if (afc <= 1)

  1228.         return -1;

  1229.     p = packet + 4;

  1230.     len = p[0];

  1231.     p++;

  1232.     if (len == 0)

  1233.         return -1;

  1234.     flags = *p++;

  1235.     len--;

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

  1237.         return -1;

  1238.     if (len < 6)

  1239.         return -1;

  1240.     v = AV_RB32(p);

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

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

  1243.     return 0;

  1244. }

  1245. 

  1246. static int mpegts_read_header(AVFormatContext *s,

  1247.                               AVFormatParameters *ap)

  1248. {

  1249.     MpegTSContext *ts = s->priv_data;

  1250.     ByteIOContext *pb = s->pb;

  1251.     uint8_t buf[5*1024];

  1252.     int len;

  1253.     int64_t pos;

  1254. 

  1255.     if (ap) {

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

  1257.         if(ap->mpeg2ts_raw){

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

  1259.             return -1;

  1260.         }

  1261.     }

  1262. 

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

  1264.     pos = url_ftell(pb);

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

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

  1267.         goto fail;

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

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

  1270.         goto fail;

  1271.     ts->stream = s;

  1272.     ts->auto_guess = 0;

  1273. 

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

  1275.         /* normal demux */

  1276. 

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

  1278.         url_fseek(pb, pos, SEEK_SET);

  1279. 

  1280.         mpegts_open_section_filter(ts, SDT_PID, sdt_cb, ts, 1);

  1281. 

  1282.         mpegts_open_section_filter(ts, PAT_PID, pat_cb, ts, 1);

  1283. 

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

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

  1286. 

  1287.         ts->auto_guess = 1;

  1288. 

  1289.         dprintf(ts->stream, "tuning done\n");

  1290. 

  1291.         s->ctx_flags |= AVFMTCTX_NOHEADER;

  1292.     } else {

  1293.         AVStream *st;

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

  1295.         int64_t pcrs[2], pcr_h;

  1296.         int packet_count[2];

  1297.         uint8_t packet[TS_PACKET_SIZE];

  1298. 

  1299.         /* only read packets */

  1300. 

  1301.         st = av_new_stream(s, 0);

  1302.         if (!st)

  1303.             goto fail;

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

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

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

  1307. 

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

  1309.         pcr_pid = -1;

  1310.         nb_pcrs = 0;

  1311.         nb_packets = 0;

  1312.         for(;;) {

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

  1314.             if (ret < 0)

  1315.                 return -1;

  1316.             pid = AV_RB16(packet + 1) & 0x1fff;

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

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

  1319.                 pcr_pid = pid;

  1320.                 packet_count[nb_pcrs] = nb_packets;

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

  1322.                 nb_pcrs++;

  1323.                 if (nb_pcrs >= 2)

  1324.                     break;

  1325.             }

  1326.             nb_packets++;

  1327.         }

  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.     int ret, i;

  1399. 

  1400.     if (url_ftell(s->pb) != ts->last_pos) {

  1401.         /* seek detected, flush pes buffer */

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

  1403.             if (ts->pids[i] && ts->pids[i]->type == MPEGTS_PES) {

  1404.                 PESContext *pes = ts->pids[i]->u.pes_filter.opaque;

  1405.                 av_freep(&pes->buffer);

  1406.                 pes->data_index = 0;

  1407.                 pes->state = MPEGTS_SKIP; /* skip until pes header */

  1408.             }

  1409.         }

  1410.     }

  1411. 

  1412.     ts->pkt = pkt;

  1413.     ret = handle_packets(ts, 0);

  1414.     if (ret < 0) {

  1415.         /* flush pes data left */

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

  1417.             if (ts->pids[i] && ts->pids[i]->type == MPEGTS_PES) {

  1418.                 PESContext *pes = ts->pids[i]->u.pes_filter.opaque;

  1419.                 if (pes->state == MPEGTS_PAYLOAD && pes->data_index > 0) {

  1420.                     new_pes_packet(pes, pkt);

  1421.                     ret = 0;

  1422.                     break;

  1423.                 }

  1424.             }

  1425.         }

  1426.     }

  1427. 

  1428.     ts->last_pos = url_ftell(s->pb);

  1429. 

  1430.     return ret;

  1431. }

  1432. 

  1433. static int mpegts_read_close(AVFormatContext *s)

  1434. {

  1435.     MpegTSContext *ts = s->priv_data;

  1436.     int i;

  1437. 

  1438.     clear_programs(ts);

  1439. 

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

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

  1442. 

  1443.     return 0;

  1444. }

  1445. 

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

  1447.                               int64_t *ppos, int64_t pos_limit)

  1448. {

  1449.     MpegTSContext *ts = s->priv_data;

  1450.     int64_t pos, timestamp;

  1451.     uint8_t buf[TS_PACKET_SIZE];

  1452.     int pcr_l, pcr_pid = ((PESContext*)s->streams[stream_index]->priv_data)->pcr_pid;

  1453.     const int find_next= 1;

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

  1455.     if (find_next) {

  1456.         for(;;) {

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

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

  1459.                 return AV_NOPTS_VALUE;

  1460.             if ((pcr_pid < 0 || (AV_RB16(buf + 1) & 0x1fff) == pcr_pid) &&

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

  1462.                 break;

  1463.             }

  1464.             pos += ts->raw_packet_size;

  1465.         }

  1466.     } else {

  1467.         for(;;) {

  1468.             pos -= ts->raw_packet_size;

  1469.             if (pos < 0)

  1470.                 return AV_NOPTS_VALUE;

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

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

  1473.                 return AV_NOPTS_VALUE;

  1474.             if ((pcr_pid < 0 || (AV_RB16(buf + 1) & 0x1fff) == pcr_pid) &&

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

  1476.                 break;

  1477.             }

  1478.         }

  1479.     }

  1480.     *ppos = pos;

  1481. 

  1482.     return timestamp;

  1483. }

  1484. 

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

  1486.     MpegTSContext *ts = s->priv_data;

  1487.     uint8_t buf[TS_PACKET_SIZE];

  1488.     int64_t pos;

  1489. 

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

  1491.         return -1;

  1492. 

  1493.     pos= url_ftell(s->pb);

  1494. 

  1495.     for(;;) {

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

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

  1498.             return -1;

  1499. //        pid = AV_RB16(buf + 1) & 0x1fff;

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

  1501.         pos += ts->raw_packet_size;

  1502.     }

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

  1504. 

  1505.     return 0;

  1506. }

  1507. 

  1508. /**************************************************************/

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

  1510. 

  1511. MpegTSContext *mpegts_parse_open(AVFormatContext *s)

  1512. {

  1513.     MpegTSContext *ts;

  1514. 

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

  1516.     if (!ts)

  1517.         return NULL;

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

  1519.     ts->raw_packet_size = TS_PACKET_SIZE;

  1520.     ts->stream = s;

  1521.     ts->auto_guess = 1;

  1522.     return ts;

  1523. }

  1524. 

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

  1526.    packet is output */

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

  1528.                         const uint8_t *buf, int len)

  1529. {

  1530.     int len1;

  1531. 

  1532.     len1 = len;

  1533.     ts->pkt = pkt;

  1534.     ts->stop_parse = 0;

  1535.     for(;;) {

  1536.         if (ts->stop_parse>0)

  1537.             break;

  1538.         if (len < TS_PACKET_SIZE)

  1539.             return -1;

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

  1541.             buf++;

  1542.             len--;

  1543.         } else {

  1544.             handle_packet(ts, buf);

  1545.             buf += TS_PACKET_SIZE;

  1546.             len -= TS_PACKET_SIZE;

  1547.         }

  1548.     }

  1549.     return len1 - len;

  1550. }

  1551. 

  1552. void mpegts_parse_close(MpegTSContext *ts)

  1553. {

  1554.     int i;

  1555. 

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

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

  1558.     av_free(ts);

  1559. }

  1560. 

  1561. AVInputFormat mpegts_demuxer = {

  1562.     "mpegts",

  1563.     NULL_IF_CONFIG_SMALL("MPEG-2 transport stream format"),

  1564.     sizeof(MpegTSContext),

  1565.     mpegts_probe,

  1566.     mpegts_read_header,

  1567.     mpegts_read_packet,

  1568.     mpegts_read_close,

  1569.     read_seek,

  1570.     mpegts_get_pcr,

  1571.     .flags = AVFMT_SHOW_IDS|AVFMT_TS_DISCONT,

  1572. };

  1573. 

  1574. AVInputFormat mpegtsraw_demuxer = {

  1575.     "mpegtsraw",

  1576.     NULL_IF_CONFIG_SMALL("MPEG-2 raw transport stream format"),

  1577.     sizeof(MpegTSContext),

  1578.     NULL,

  1579.     mpegts_read_header,

  1580.     mpegts_raw_read_packet,

  1581.     mpegts_read_close,

  1582.     read_seek,

  1583.     mpegts_get_pcr,

  1584.     .flags = AVFMT_SHOW_IDS|AVFMT_TS_DISCONT,

  1585. };