Subversion Repositories Kolibri OS

Rev

Blame | Last modification | View Log | RSS feed

  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. #include "libavutil/buffer.h"
  23. #include "libavutil/crc.h"
  24. #include "libavutil/internal.h"
  25. #include "libavutil/intreadwrite.h"
  26. #include "libavutil/log.h"
  27. #include "libavutil/dict.h"
  28. #include "libavutil/mathematics.h"
  29. #include "libavutil/opt.h"
  30. #include "libavutil/avassert.h"
  31. #include "libavcodec/bytestream.h"
  32. #include "libavcodec/get_bits.h"
  33. #include "libavcodec/opus.h"
  34. #include "avformat.h"
  35. #include "mpegts.h"
  36. #include "internal.h"
  37. #include "avio_internal.h"
  38. #include "mpeg.h"
  39. #include "isom.h"
  40.  
  41. /* maximum size in which we look for synchronisation if
  42.  * synchronisation is lost */
  43. #define MAX_RESYNC_SIZE 65536
  44.  
  45. #define MAX_PES_PAYLOAD 200 * 1024
  46.  
  47. #define MAX_MP4_DESCR_COUNT 16
  48.  
  49. #define MOD_UNLIKELY(modulus, dividend, divisor, prev_dividend)                \
  50.     do {                                                                       \
  51.         if ((prev_dividend) == 0 || (dividend) - (prev_dividend) != (divisor)) \
  52.             (modulus) = (dividend) % (divisor);                                \
  53.         (prev_dividend) = (dividend);                                          \
  54.     } while (0)
  55.  
  56. enum MpegTSFilterType {
  57.     MPEGTS_PES,
  58.     MPEGTS_SECTION,
  59.     MPEGTS_PCR,
  60. };
  61.  
  62. typedef struct MpegTSFilter MpegTSFilter;
  63.  
  64. typedef int PESCallback (MpegTSFilter *f, const uint8_t *buf, int len,
  65.                          int is_start, int64_t pos);
  66.  
  67. typedef struct MpegTSPESFilter {
  68.     PESCallback *pes_cb;
  69.     void *opaque;
  70. } MpegTSPESFilter;
  71.  
  72. typedef void SectionCallback (MpegTSFilter *f, const uint8_t *buf, int len);
  73.  
  74. typedef void SetServiceCallback (void *opaque, int ret);
  75.  
  76. typedef struct MpegTSSectionFilter {
  77.     int section_index;
  78.     int section_h_size;
  79.     int last_ver;
  80.     unsigned crc;
  81.     unsigned last_crc;
  82.     uint8_t *section_buf;
  83.     unsigned int check_crc : 1;
  84.     unsigned int end_of_section_reached : 1;
  85.     SectionCallback *section_cb;
  86.     void *opaque;
  87. } MpegTSSectionFilter;
  88.  
  89. struct MpegTSFilter {
  90.     int pid;
  91.     int es_id;
  92.     int last_cc; /* last cc code (-1 if first packet) */
  93.     int64_t last_pcr;
  94.     enum MpegTSFilterType type;
  95.     union {
  96.         MpegTSPESFilter pes_filter;
  97.         MpegTSSectionFilter section_filter;
  98.     } u;
  99. };
  100.  
  101. #define MAX_PIDS_PER_PROGRAM 64
  102. struct Program {
  103.     unsigned int id; // program id/service id
  104.     unsigned int nb_pids;
  105.     unsigned int pids[MAX_PIDS_PER_PROGRAM];
  106.  
  107.     /** have we found pmt for this program */
  108.     int pmt_found;
  109. };
  110.  
  111. struct MpegTSContext {
  112.     const AVClass *class;
  113.     /* user data */
  114.     AVFormatContext *stream;
  115.     /** raw packet size, including FEC if present */
  116.     int raw_packet_size;
  117.  
  118.     int size_stat[3];
  119.     int size_stat_count;
  120. #define SIZE_STAT_THRESHOLD 10
  121.  
  122.     int64_t pos47_full;
  123.  
  124.     /** if true, all pids are analyzed to find streams */
  125.     int auto_guess;
  126.  
  127.     /** compute exact PCR for each transport stream packet */
  128.     int mpeg2ts_compute_pcr;
  129.  
  130.     /** fix dvb teletext pts                                 */
  131.     int fix_teletext_pts;
  132.  
  133.     int64_t cur_pcr;    /**< used to estimate the exact PCR */
  134.     int pcr_incr;       /**< used to estimate the exact PCR */
  135.  
  136.     /* data needed to handle file based ts */
  137.     /** stop parsing loop */
  138.     int stop_parse;
  139.     /** packet containing Audio/Video data */
  140.     AVPacket *pkt;
  141.     /** to detect seek */
  142.     int64_t last_pos;
  143.  
  144.     int skip_changes;
  145.     int skip_clear;
  146.  
  147.     int scan_all_pmts;
  148.  
  149.     int resync_size;
  150.  
  151.     /******************************************/
  152.     /* private mpegts data */
  153.     /* scan context */
  154.     /** structure to keep track of Program->pids mapping */
  155.     unsigned int nb_prg;
  156.     struct Program *prg;
  157.  
  158.     int8_t crc_validity[NB_PID_MAX];
  159.     /** filters for various streams specified by PMT + for the PAT and PMT */
  160.     MpegTSFilter *pids[NB_PID_MAX];
  161.     int current_pid;
  162. };
  163.  
  164. #define MPEGTS_OPTIONS \
  165.     { "resync_size",   "set size limit for looking up a new synchronization", offsetof(MpegTSContext, resync_size), AV_OPT_TYPE_INT,  { .i64 =  MAX_RESYNC_SIZE}, 0, INT_MAX,  AV_OPT_FLAG_DECODING_PARAM }
  166.  
  167. static const AVOption options[] = {
  168.     MPEGTS_OPTIONS,
  169.     {"fix_teletext_pts", "try to fix pts values of dvb teletext streams", offsetof(MpegTSContext, fix_teletext_pts), AV_OPT_TYPE_INT,
  170.      {.i64 = 1}, 0, 1, AV_OPT_FLAG_DECODING_PARAM },
  171.     {"ts_packetsize", "output option carrying the raw packet size", offsetof(MpegTSContext, raw_packet_size), AV_OPT_TYPE_INT,
  172.      {.i64 = 0}, 0, 0, AV_OPT_FLAG_DECODING_PARAM | AV_OPT_FLAG_EXPORT | AV_OPT_FLAG_READONLY },
  173.     {"scan_all_pmts",   "scan and combine all PMTs", offsetof(MpegTSContext, scan_all_pmts), AV_OPT_TYPE_INT,
  174.      { .i64 =  -1}, -1, 1,  AV_OPT_FLAG_DECODING_PARAM },
  175.     {"skip_changes", "skip changing / adding streams / programs", offsetof(MpegTSContext, skip_changes), AV_OPT_TYPE_INT,
  176.      {.i64 = 0}, 0, 1, 0 },
  177.     {"skip_clear", "skip clearing programs", offsetof(MpegTSContext, skip_clear), AV_OPT_TYPE_INT,
  178.      {.i64 = 0}, 0, 1, 0 },
  179.     { NULL },
  180. };
  181.  
  182. static const AVClass mpegts_class = {
  183.     .class_name = "mpegts demuxer",
  184.     .item_name  = av_default_item_name,
  185.     .option     = options,
  186.     .version    = LIBAVUTIL_VERSION_INT,
  187. };
  188.  
  189. static const AVOption raw_options[] = {
  190.     MPEGTS_OPTIONS,
  191.     { "compute_pcr",   "compute exact PCR for each transport stream packet",
  192.           offsetof(MpegTSContext, mpeg2ts_compute_pcr), AV_OPT_TYPE_INT,
  193.           { .i64 = 0 }, 0, 1,  AV_OPT_FLAG_DECODING_PARAM },
  194.     { "ts_packetsize", "output option carrying the raw packet size",
  195.       offsetof(MpegTSContext, raw_packet_size), AV_OPT_TYPE_INT,
  196.       { .i64 = 0 }, 0, 0,
  197.       AV_OPT_FLAG_DECODING_PARAM | AV_OPT_FLAG_EXPORT | AV_OPT_FLAG_READONLY },
  198.     { NULL },
  199. };
  200.  
  201. static const AVClass mpegtsraw_class = {
  202.     .class_name = "mpegtsraw demuxer",
  203.     .item_name  = av_default_item_name,
  204.     .option     = raw_options,
  205.     .version    = LIBAVUTIL_VERSION_INT,
  206. };
  207.  
  208. /* TS stream handling */
  209.  
  210. enum MpegTSState {
  211.     MPEGTS_HEADER = 0,
  212.     MPEGTS_PESHEADER,
  213.     MPEGTS_PESHEADER_FILL,
  214.     MPEGTS_PAYLOAD,
  215.     MPEGTS_SKIP,
  216. };
  217.  
  218. /* enough for PES header + length */
  219. #define PES_START_SIZE  6
  220. #define PES_HEADER_SIZE 9
  221. #define MAX_PES_HEADER_SIZE (9 + 255)
  222.  
  223. typedef struct PESContext {
  224.     int pid;
  225.     int pcr_pid; /**< if -1 then all packets containing PCR are considered */
  226.     int stream_type;
  227.     MpegTSContext *ts;
  228.     AVFormatContext *stream;
  229.     AVStream *st;
  230.     AVStream *sub_st; /**< stream for the embedded AC3 stream in HDMV TrueHD */
  231.     enum MpegTSState state;
  232.     /* used to get the format */
  233.     int data_index;
  234.     int flags; /**< copied to the AVPacket flags */
  235.     int total_size;
  236.     int pes_header_size;
  237.     int extended_stream_id;
  238.     int64_t pts, dts;
  239.     int64_t ts_packet_pos; /**< position of first TS packet of this PES packet */
  240.     uint8_t header[MAX_PES_HEADER_SIZE];
  241.     AVBufferRef *buffer;
  242.     SLConfigDescr sl;
  243. } PESContext;
  244.  
  245. extern AVInputFormat ff_mpegts_demuxer;
  246.  
  247. static struct Program * get_program(MpegTSContext *ts, unsigned int programid)
  248. {
  249.     int i;
  250.     for (i = 0; i < ts->nb_prg; i++) {
  251.         if (ts->prg[i].id == programid) {
  252.             return &ts->prg[i];
  253.         }
  254.     }
  255.     return NULL;
  256. }
  257.  
  258. static void clear_avprogram(MpegTSContext *ts, unsigned int programid)
  259. {
  260.     AVProgram *prg = NULL;
  261.     int i;
  262.  
  263.     for (i = 0; i < ts->stream->nb_programs; i++)
  264.         if (ts->stream->programs[i]->id == programid) {
  265.             prg = ts->stream->programs[i];
  266.             break;
  267.         }
  268.     if (!prg)
  269.         return;
  270.     prg->nb_stream_indexes = 0;
  271. }
  272.  
  273. static void clear_program(MpegTSContext *ts, unsigned int programid)
  274. {
  275.     int i;
  276.  
  277.     clear_avprogram(ts, programid);
  278.     for (i = 0; i < ts->nb_prg; i++)
  279.         if (ts->prg[i].id == programid) {
  280.             ts->prg[i].nb_pids = 0;
  281.             ts->prg[i].pmt_found = 0;
  282.         }
  283. }
  284.  
  285. static void clear_programs(MpegTSContext *ts)
  286. {
  287.     av_freep(&ts->prg);
  288.     ts->nb_prg = 0;
  289. }
  290.  
  291. static void add_pat_entry(MpegTSContext *ts, unsigned int programid)
  292. {
  293.     struct Program *p;
  294.     if (av_reallocp_array(&ts->prg, ts->nb_prg + 1, sizeof(*ts->prg)) < 0) {
  295.         ts->nb_prg = 0;
  296.         return;
  297.     }
  298.     p = &ts->prg[ts->nb_prg];
  299.     p->id = programid;
  300.     p->nb_pids = 0;
  301.     p->pmt_found = 0;
  302.     ts->nb_prg++;
  303. }
  304.  
  305. static void add_pid_to_pmt(MpegTSContext *ts, unsigned int programid,
  306.                            unsigned int pid)
  307. {
  308.     struct Program *p = get_program(ts, programid);
  309.     int i;
  310.     if (!p)
  311.         return;
  312.  
  313.     if (p->nb_pids >= MAX_PIDS_PER_PROGRAM)
  314.         return;
  315.  
  316.     for (i = 0; i < p->nb_pids; i++)
  317.         if (p->pids[i] == pid)
  318.             return;
  319.  
  320.     p->pids[p->nb_pids++] = pid;
  321. }
  322.  
  323. static void set_pmt_found(MpegTSContext *ts, unsigned int programid)
  324. {
  325.     struct Program *p = get_program(ts, programid);
  326.     if (!p)
  327.         return;
  328.  
  329.     p->pmt_found = 1;
  330. }
  331.  
  332. static void set_pcr_pid(AVFormatContext *s, unsigned int programid, unsigned int pid)
  333. {
  334.     int i;
  335.     for (i = 0; i < s->nb_programs; i++) {
  336.         if (s->programs[i]->id == programid) {
  337.             s->programs[i]->pcr_pid = pid;
  338.             break;
  339.         }
  340.     }
  341. }
  342.  
  343. /**
  344.  * @brief discard_pid() decides if the pid is to be discarded according
  345.  *                      to caller's programs selection
  346.  * @param ts    : - TS context
  347.  * @param pid   : - pid
  348.  * @return 1 if the pid is only comprised in programs that have .discard=AVDISCARD_ALL
  349.  *         0 otherwise
  350.  */
  351. static int discard_pid(MpegTSContext *ts, unsigned int pid)
  352. {
  353.     int i, j, k;
  354.     int used = 0, discarded = 0;
  355.     struct Program *p;
  356.  
  357.     /* If none of the programs have .discard=AVDISCARD_ALL then there's
  358.      * no way we have to discard this packet */
  359.     for (k = 0; k < ts->stream->nb_programs; k++)
  360.         if (ts->stream->programs[k]->discard == AVDISCARD_ALL)
  361.             break;
  362.     if (k == ts->stream->nb_programs)
  363.         return 0;
  364.  
  365.     for (i = 0; i < ts->nb_prg; i++) {
  366.         p = &ts->prg[i];
  367.         for (j = 0; j < p->nb_pids; j++) {
  368.             if (p->pids[j] != pid)
  369.                 continue;
  370.             // is program with id p->id set to be discarded?
  371.             for (k = 0; k < ts->stream->nb_programs; k++) {
  372.                 if (ts->stream->programs[k]->id == p->id) {
  373.                     if (ts->stream->programs[k]->discard == AVDISCARD_ALL)
  374.                         discarded++;
  375.                     else
  376.                         used++;
  377.                 }
  378.             }
  379.         }
  380.     }
  381.  
  382.     return !used && discarded;
  383. }
  384.  
  385. /**
  386.  *  Assemble PES packets out of TS packets, and then call the "section_cb"
  387.  *  function when they are complete.
  388.  */
  389. static void write_section_data(MpegTSContext *ts, MpegTSFilter *tss1,
  390.                                const uint8_t *buf, int buf_size, int is_start)
  391. {
  392.     MpegTSSectionFilter *tss = &tss1->u.section_filter;
  393.     int len;
  394.  
  395.     if (is_start) {
  396.         memcpy(tss->section_buf, buf, buf_size);
  397.         tss->section_index = buf_size;
  398.         tss->section_h_size = -1;
  399.         tss->end_of_section_reached = 0;
  400.     } else {
  401.         if (tss->end_of_section_reached)
  402.             return;
  403.         len = 4096 - tss->section_index;
  404.         if (buf_size < len)
  405.             len = buf_size;
  406.         memcpy(tss->section_buf + tss->section_index, buf, len);
  407.         tss->section_index += len;
  408.     }
  409.  
  410.     /* compute section length if possible */
  411.     if (tss->section_h_size == -1 && tss->section_index >= 3) {
  412.         len = (AV_RB16(tss->section_buf + 1) & 0xfff) + 3;
  413.         if (len > 4096)
  414.             return;
  415.         tss->section_h_size = len;
  416.     }
  417.  
  418.     if (tss->section_h_size != -1 &&
  419.         tss->section_index >= tss->section_h_size) {
  420.         int crc_valid = 1;
  421.         tss->end_of_section_reached = 1;
  422.  
  423.         if (tss->check_crc) {
  424.             crc_valid = !av_crc(av_crc_get_table(AV_CRC_32_IEEE), -1, tss->section_buf, tss->section_h_size);
  425.             if (tss->section_h_size >= 4)
  426.                 tss->crc = AV_RB32(tss->section_buf + tss->section_h_size - 4);
  427.  
  428.             if (crc_valid) {
  429.                 ts->crc_validity[ tss1->pid ] = 100;
  430.             }else if (ts->crc_validity[ tss1->pid ] > -10) {
  431.                 ts->crc_validity[ tss1->pid ]--;
  432.             }else
  433.                 crc_valid = 2;
  434.         }
  435.         if (crc_valid) {
  436.             tss->section_cb(tss1, tss->section_buf, tss->section_h_size);
  437.             if (crc_valid != 1)
  438.                 tss->last_ver = -1;
  439.         }
  440.     }
  441. }
  442.  
  443. static MpegTSFilter *mpegts_open_filter(MpegTSContext *ts, unsigned int pid,
  444.                                         enum MpegTSFilterType type)
  445. {
  446.     MpegTSFilter *filter;
  447.  
  448.     av_log(ts->stream, AV_LOG_TRACE, "Filter: pid=0x%x\n", pid);
  449.  
  450.     if (pid >= NB_PID_MAX || ts->pids[pid])
  451.         return NULL;
  452.     filter = av_mallocz(sizeof(MpegTSFilter));
  453.     if (!filter)
  454.         return NULL;
  455.     ts->pids[pid] = filter;
  456.  
  457.     filter->type    = type;
  458.     filter->pid     = pid;
  459.     filter->es_id   = -1;
  460.     filter->last_cc = -1;
  461.     filter->last_pcr= -1;
  462.  
  463.     return filter;
  464. }
  465.  
  466. static MpegTSFilter *mpegts_open_section_filter(MpegTSContext *ts,
  467.                                                 unsigned int pid,
  468.                                                 SectionCallback *section_cb,
  469.                                                 void *opaque,
  470.                                                 int check_crc)
  471. {
  472.     MpegTSFilter *filter;
  473.     MpegTSSectionFilter *sec;
  474.  
  475.     if (!(filter = mpegts_open_filter(ts, pid, MPEGTS_SECTION)))
  476.         return NULL;
  477.     sec = &filter->u.section_filter;
  478.     sec->section_cb  = section_cb;
  479.     sec->opaque      = opaque;
  480.     sec->section_buf = av_malloc(MAX_SECTION_SIZE);
  481.     sec->check_crc   = check_crc;
  482.     sec->last_ver    = -1;
  483.  
  484.     if (!sec->section_buf) {
  485.         av_free(filter);
  486.         return NULL;
  487.     }
  488.     return filter;
  489. }
  490.  
  491. static MpegTSFilter *mpegts_open_pes_filter(MpegTSContext *ts, unsigned int pid,
  492.                                             PESCallback *pes_cb,
  493.                                             void *opaque)
  494. {
  495.     MpegTSFilter *filter;
  496.     MpegTSPESFilter *pes;
  497.  
  498.     if (!(filter = mpegts_open_filter(ts, pid, MPEGTS_PES)))
  499.         return NULL;
  500.  
  501.     pes = &filter->u.pes_filter;
  502.     pes->pes_cb = pes_cb;
  503.     pes->opaque = opaque;
  504.     return filter;
  505. }
  506.  
  507. static MpegTSFilter *mpegts_open_pcr_filter(MpegTSContext *ts, unsigned int pid)
  508. {
  509.     return mpegts_open_filter(ts, pid, MPEGTS_PCR);
  510. }
  511.  
  512. static void mpegts_close_filter(MpegTSContext *ts, MpegTSFilter *filter)
  513. {
  514.     int pid;
  515.  
  516.     pid = filter->pid;
  517.     if (filter->type == MPEGTS_SECTION)
  518.         av_freep(&filter->u.section_filter.section_buf);
  519.     else if (filter->type == MPEGTS_PES) {
  520.         PESContext *pes = filter->u.pes_filter.opaque;
  521.         av_buffer_unref(&pes->buffer);
  522.         /* referenced private data will be freed later in
  523.          * avformat_close_input */
  524.         if (!((PESContext *)filter->u.pes_filter.opaque)->st) {
  525.             av_freep(&filter->u.pes_filter.opaque);
  526.         }
  527.     }
  528.  
  529.     av_free(filter);
  530.     ts->pids[pid] = NULL;
  531. }
  532.  
  533. static int analyze(const uint8_t *buf, int size, int packet_size, int *index,
  534.                    int probe)
  535. {
  536.     int stat[TS_MAX_PACKET_SIZE];
  537.     int stat_all = 0;
  538.     int i;
  539.     int best_score = 0;
  540.  
  541.     memset(stat, 0, packet_size * sizeof(*stat));
  542.  
  543.     for (i = 0; i < size - 3; i++) {
  544.         if (buf[i] == 0x47 &&
  545.             (!probe || (!(buf[i + 1] & 0x80) && buf[i + 3] != 0x47))) {
  546.             int x = i % packet_size;
  547.             stat[x]++;
  548.             stat_all++;
  549.             if (stat[x] > best_score) {
  550.                 best_score = stat[x];
  551.                 if (index)
  552.                     *index = x;
  553.             }
  554.         }
  555.     }
  556.  
  557.     return best_score - FFMAX(stat_all - 10*best_score, 0)/10;
  558. }
  559.  
  560. /* autodetect fec presence. Must have at least 1024 bytes  */
  561. static int get_packet_size(const uint8_t *buf, int size)
  562. {
  563.     int score, fec_score, dvhs_score;
  564.  
  565.     if (size < (TS_FEC_PACKET_SIZE * 5 + 1))
  566.         return AVERROR_INVALIDDATA;
  567.  
  568.     score      = analyze(buf, size, TS_PACKET_SIZE,      NULL, 0);
  569.     dvhs_score = analyze(buf, size, TS_DVHS_PACKET_SIZE, NULL, 0);
  570.     fec_score  = analyze(buf, size, TS_FEC_PACKET_SIZE,  NULL, 0);
  571.     av_log(NULL, AV_LOG_TRACE, "score: %d, dvhs_score: %d, fec_score: %d \n",
  572.             score, dvhs_score, fec_score);
  573.  
  574.     if (score > fec_score && score > dvhs_score)
  575.         return TS_PACKET_SIZE;
  576.     else if (dvhs_score > score && dvhs_score > fec_score)
  577.         return TS_DVHS_PACKET_SIZE;
  578.     else if (score < fec_score && dvhs_score < fec_score)
  579.         return TS_FEC_PACKET_SIZE;
  580.     else
  581.         return AVERROR_INVALIDDATA;
  582. }
  583.  
  584. typedef struct SectionHeader {
  585.     uint8_t tid;
  586.     uint16_t id;
  587.     uint8_t version;
  588.     uint8_t sec_num;
  589.     uint8_t last_sec_num;
  590. } SectionHeader;
  591.  
  592. static int skip_identical(const SectionHeader *h, MpegTSSectionFilter *tssf)
  593. {
  594.     if (h->version == tssf->last_ver && tssf->last_crc == tssf->crc)
  595.         return 1;
  596.  
  597.     tssf->last_ver = h->version;
  598.     tssf->last_crc = tssf->crc;
  599.  
  600.     return 0;
  601. }
  602.  
  603. static inline int get8(const uint8_t **pp, const uint8_t *p_end)
  604. {
  605.     const uint8_t *p;
  606.     int c;
  607.  
  608.     p = *pp;
  609.     if (p >= p_end)
  610.         return AVERROR_INVALIDDATA;
  611.     c   = *p++;
  612.     *pp = p;
  613.     return c;
  614. }
  615.  
  616. static inline int get16(const uint8_t **pp, const uint8_t *p_end)
  617. {
  618.     const uint8_t *p;
  619.     int c;
  620.  
  621.     p = *pp;
  622.     if (1 >= p_end - p)
  623.         return AVERROR_INVALIDDATA;
  624.     c   = AV_RB16(p);
  625.     p  += 2;
  626.     *pp = p;
  627.     return c;
  628. }
  629.  
  630. /* read and allocate a DVB string preceded by its length */
  631. static char *getstr8(const uint8_t **pp, const uint8_t *p_end)
  632. {
  633.     int len;
  634.     const uint8_t *p;
  635.     char *str;
  636.  
  637.     p   = *pp;
  638.     len = get8(&p, p_end);
  639.     if (len < 0)
  640.         return NULL;
  641.     if (len > p_end - p)
  642.         return NULL;
  643.     str = av_malloc(len + 1);
  644.     if (!str)
  645.         return NULL;
  646.     memcpy(str, p, len);
  647.     str[len] = '\0';
  648.     p  += len;
  649.     *pp = p;
  650.     return str;
  651. }
  652.  
  653. static int parse_section_header(SectionHeader *h,
  654.                                 const uint8_t **pp, const uint8_t *p_end)
  655. {
  656.     int val;
  657.  
  658.     val = get8(pp, p_end);
  659.     if (val < 0)
  660.         return val;
  661.     h->tid = val;
  662.     *pp += 2;
  663.     val  = get16(pp, p_end);
  664.     if (val < 0)
  665.         return val;
  666.     h->id = val;
  667.     val = get8(pp, p_end);
  668.     if (val < 0)
  669.         return val;
  670.     h->version = (val >> 1) & 0x1f;
  671.     val = get8(pp, p_end);
  672.     if (val < 0)
  673.         return val;
  674.     h->sec_num = val;
  675.     val = get8(pp, p_end);
  676.     if (val < 0)
  677.         return val;
  678.     h->last_sec_num = val;
  679.     return 0;
  680. }
  681.  
  682. typedef struct StreamType {
  683.     uint32_t stream_type;
  684.     enum AVMediaType codec_type;
  685.     enum AVCodecID codec_id;
  686. } StreamType;
  687.  
  688. static const StreamType ISO_types[] = {
  689.     { 0x01, AVMEDIA_TYPE_VIDEO, AV_CODEC_ID_MPEG2VIDEO },
  690.     { 0x02, AVMEDIA_TYPE_VIDEO, AV_CODEC_ID_MPEG2VIDEO },
  691.     { 0x03, AVMEDIA_TYPE_AUDIO, AV_CODEC_ID_MP3        },
  692.     { 0x04, AVMEDIA_TYPE_AUDIO, AV_CODEC_ID_MP3        },
  693.     { 0x0f, AVMEDIA_TYPE_AUDIO, AV_CODEC_ID_AAC        },
  694.     { 0x10, AVMEDIA_TYPE_VIDEO, AV_CODEC_ID_MPEG4      },
  695.     /* Makito encoder sets stream type 0x11 for AAC,
  696.      * so auto-detect LOAS/LATM instead of hardcoding it. */
  697. #if !CONFIG_LOAS_DEMUXER
  698.     { 0x11, AVMEDIA_TYPE_AUDIO, AV_CODEC_ID_AAC_LATM   }, /* LATM syntax */
  699. #endif
  700.     { 0x1b, AVMEDIA_TYPE_VIDEO, AV_CODEC_ID_H264       },
  701.     { 0x20, AVMEDIA_TYPE_VIDEO, AV_CODEC_ID_H264       },
  702.     { 0x21, AVMEDIA_TYPE_VIDEO, AV_CODEC_ID_JPEG2000   },
  703.     { 0x24, AVMEDIA_TYPE_VIDEO, AV_CODEC_ID_HEVC       },
  704.     { 0x42, AVMEDIA_TYPE_VIDEO, AV_CODEC_ID_CAVS       },
  705.     { 0xd1, AVMEDIA_TYPE_VIDEO, AV_CODEC_ID_DIRAC      },
  706.     { 0xea, AVMEDIA_TYPE_VIDEO, AV_CODEC_ID_VC1        },
  707.     { 0 },
  708. };
  709.  
  710. static const StreamType HDMV_types[] = {
  711.     { 0x80, AVMEDIA_TYPE_AUDIO,    AV_CODEC_ID_PCM_BLURAY        },
  712.     { 0x81, AVMEDIA_TYPE_AUDIO,    AV_CODEC_ID_AC3               },
  713.     { 0x82, AVMEDIA_TYPE_AUDIO,    AV_CODEC_ID_DTS               },
  714.     { 0x83, AVMEDIA_TYPE_AUDIO,    AV_CODEC_ID_TRUEHD            },
  715.     { 0x84, AVMEDIA_TYPE_AUDIO,    AV_CODEC_ID_EAC3              },
  716.     { 0x85, AVMEDIA_TYPE_AUDIO,    AV_CODEC_ID_DTS               }, /* DTS HD */
  717.     { 0x86, AVMEDIA_TYPE_AUDIO,    AV_CODEC_ID_DTS               }, /* DTS HD MASTER*/
  718.     { 0xa1, AVMEDIA_TYPE_AUDIO,    AV_CODEC_ID_EAC3              }, /* E-AC3 Secondary Audio */
  719.     { 0xa2, AVMEDIA_TYPE_AUDIO,    AV_CODEC_ID_DTS               }, /* DTS Express Secondary Audio */
  720.     { 0x90, AVMEDIA_TYPE_SUBTITLE, AV_CODEC_ID_HDMV_PGS_SUBTITLE },
  721.     { 0x92, AVMEDIA_TYPE_SUBTITLE, AV_CODEC_ID_HDMV_TEXT_SUBTITLE },
  722.     { 0 },
  723. };
  724.  
  725. /* ATSC ? */
  726. static const StreamType MISC_types[] = {
  727.     { 0x81, AVMEDIA_TYPE_AUDIO, AV_CODEC_ID_AC3 },
  728.     { 0x8a, AVMEDIA_TYPE_AUDIO, AV_CODEC_ID_DTS },
  729.     { 0 },
  730. };
  731.  
  732. static const StreamType REGD_types[] = {
  733.     { MKTAG('d', 'r', 'a', 'c'), AVMEDIA_TYPE_VIDEO, AV_CODEC_ID_DIRAC },
  734.     { MKTAG('A', 'C', '-', '3'), AVMEDIA_TYPE_AUDIO, AV_CODEC_ID_AC3   },
  735.     { MKTAG('B', 'S', 'S', 'D'), AVMEDIA_TYPE_AUDIO, AV_CODEC_ID_S302M },
  736.     { MKTAG('D', 'T', 'S', '1'), AVMEDIA_TYPE_AUDIO, AV_CODEC_ID_DTS   },
  737.     { MKTAG('D', 'T', 'S', '2'), AVMEDIA_TYPE_AUDIO, AV_CODEC_ID_DTS   },
  738.     { MKTAG('D', 'T', 'S', '3'), AVMEDIA_TYPE_AUDIO, AV_CODEC_ID_DTS   },
  739.     { MKTAG('H', 'E', 'V', 'C'), AVMEDIA_TYPE_VIDEO, AV_CODEC_ID_HEVC  },
  740.     { MKTAG('K', 'L', 'V', 'A'), AVMEDIA_TYPE_DATA,  AV_CODEC_ID_SMPTE_KLV },
  741.     { MKTAG('V', 'C', '-', '1'), AVMEDIA_TYPE_VIDEO, AV_CODEC_ID_VC1   },
  742.     { MKTAG('O', 'p', 'u', 's'), AVMEDIA_TYPE_AUDIO, AV_CODEC_ID_OPUS  },
  743.     { 0 },
  744. };
  745.  
  746. static const StreamType METADATA_types[] = {
  747.     { MKTAG('K','L','V','A'), AVMEDIA_TYPE_DATA, AV_CODEC_ID_SMPTE_KLV },
  748.     { MKTAG('I','D','3',' '), AVMEDIA_TYPE_DATA, AV_CODEC_ID_TIMED_ID3 },
  749.     { 0 },
  750. };
  751.  
  752. /* descriptor present */
  753. static const StreamType DESC_types[] = {
  754.     { 0x6a, AVMEDIA_TYPE_AUDIO,    AV_CODEC_ID_AC3          }, /* AC-3 descriptor */
  755.     { 0x7a, AVMEDIA_TYPE_AUDIO,    AV_CODEC_ID_EAC3         }, /* E-AC-3 descriptor */
  756.     { 0x7b, AVMEDIA_TYPE_AUDIO,    AV_CODEC_ID_DTS          },
  757.     { 0x56, AVMEDIA_TYPE_SUBTITLE, AV_CODEC_ID_DVB_TELETEXT },
  758.     { 0x59, AVMEDIA_TYPE_SUBTITLE, AV_CODEC_ID_DVB_SUBTITLE }, /* subtitling descriptor */
  759.     { 0 },
  760. };
  761.  
  762. static void mpegts_find_stream_type(AVStream *st,
  763.                                     uint32_t stream_type,
  764.                                     const StreamType *types)
  765. {
  766.     if (avcodec_is_open(st->codec)) {
  767.         av_log(NULL, AV_LOG_DEBUG, "cannot set stream info, codec is open\n");
  768.         return;
  769.     }
  770.  
  771.     for (; types->stream_type; types++)
  772.         if (stream_type == types->stream_type) {
  773.             st->codec->codec_type = types->codec_type;
  774.             st->codec->codec_id   = types->codec_id;
  775.             st->request_probe     = 0;
  776.             return;
  777.         }
  778. }
  779.  
  780. static int mpegts_set_stream_info(AVStream *st, PESContext *pes,
  781.                                   uint32_t stream_type, uint32_t prog_reg_desc)
  782. {
  783.     int old_codec_type = st->codec->codec_type;
  784.     int old_codec_id  = st->codec->codec_id;
  785.  
  786.     if (avcodec_is_open(st->codec)) {
  787.         av_log(pes->stream, AV_LOG_DEBUG, "cannot set stream info, codec is open\n");
  788.         return 0;
  789.     }
  790.  
  791.     avpriv_set_pts_info(st, 33, 1, 90000);
  792.     st->priv_data         = pes;
  793.     st->codec->codec_type = AVMEDIA_TYPE_DATA;
  794.     st->codec->codec_id   = AV_CODEC_ID_NONE;
  795.     st->need_parsing      = AVSTREAM_PARSE_FULL;
  796.     pes->st          = st;
  797.     pes->stream_type = stream_type;
  798.  
  799.     av_log(pes->stream, AV_LOG_DEBUG,
  800.            "stream=%d stream_type=%x pid=%x prog_reg_desc=%.4s\n",
  801.            st->index, pes->stream_type, pes->pid, (char *)&prog_reg_desc);
  802.  
  803.     st->codec->codec_tag = pes->stream_type;
  804.  
  805.     mpegts_find_stream_type(st, pes->stream_type, ISO_types);
  806.     if ((prog_reg_desc == AV_RL32("HDMV") ||
  807.          prog_reg_desc == AV_RL32("HDPR")) &&
  808.         st->codec->codec_id == AV_CODEC_ID_NONE) {
  809.         mpegts_find_stream_type(st, pes->stream_type, HDMV_types);
  810.         if (pes->stream_type == 0x83) {
  811.             // HDMV TrueHD streams also contain an AC3 coded version of the
  812.             // audio track - add a second stream for this
  813.             AVStream *sub_st;
  814.             // priv_data cannot be shared between streams
  815.             PESContext *sub_pes = av_malloc(sizeof(*sub_pes));
  816.             if (!sub_pes)
  817.                 return AVERROR(ENOMEM);
  818.             memcpy(sub_pes, pes, sizeof(*sub_pes));
  819.  
  820.             sub_st = avformat_new_stream(pes->stream, NULL);
  821.             if (!sub_st) {
  822.                 av_free(sub_pes);
  823.                 return AVERROR(ENOMEM);
  824.             }
  825.  
  826.             sub_st->id = pes->pid;
  827.             avpriv_set_pts_info(sub_st, 33, 1, 90000);
  828.             sub_st->priv_data         = sub_pes;
  829.             sub_st->codec->codec_type = AVMEDIA_TYPE_AUDIO;
  830.             sub_st->codec->codec_id   = AV_CODEC_ID_AC3;
  831.             sub_st->need_parsing      = AVSTREAM_PARSE_FULL;
  832.             sub_pes->sub_st           = pes->sub_st = sub_st;
  833.         }
  834.     }
  835.     if (st->codec->codec_id == AV_CODEC_ID_NONE)
  836.         mpegts_find_stream_type(st, pes->stream_type, MISC_types);
  837.     if (st->codec->codec_id == AV_CODEC_ID_NONE) {
  838.         st->codec->codec_id  = old_codec_id;
  839.         st->codec->codec_type = old_codec_type;
  840.     }
  841.     if ((st->codec->codec_id == AV_CODEC_ID_NONE ||
  842.             (st->request_probe > 0 && st->request_probe < AVPROBE_SCORE_STREAM_RETRY / 5)) &&
  843.         !avcodec_is_open(st->codec) &&
  844.         st->probe_packets > 0 &&
  845.         stream_type == STREAM_TYPE_PRIVATE_DATA) {
  846.         st->codec->codec_type = AVMEDIA_TYPE_DATA;
  847.         st->codec->codec_id   = AV_CODEC_ID_BIN_DATA;
  848.         st->request_probe = AVPROBE_SCORE_STREAM_RETRY / 5;
  849.     }
  850.  
  851.     return 0;
  852. }
  853.  
  854. static void reset_pes_packet_state(PESContext *pes)
  855. {
  856.     pes->pts        = AV_NOPTS_VALUE;
  857.     pes->dts        = AV_NOPTS_VALUE;
  858.     pes->data_index = 0;
  859.     pes->flags      = 0;
  860.     av_buffer_unref(&pes->buffer);
  861. }
  862.  
  863. static void new_pes_packet(PESContext *pes, AVPacket *pkt)
  864. {
  865.     av_init_packet(pkt);
  866.  
  867.     pkt->buf  = pes->buffer;
  868.     pkt->data = pes->buffer->data;
  869.     pkt->size = pes->data_index;
  870.  
  871.     if (pes->total_size != MAX_PES_PAYLOAD &&
  872.         pes->pes_header_size + pes->data_index != pes->total_size +
  873.         PES_START_SIZE) {
  874.         av_log(pes->stream, AV_LOG_WARNING, "PES packet size mismatch\n");
  875.         pes->flags |= AV_PKT_FLAG_CORRUPT;
  876.     }
  877.     memset(pkt->data + pkt->size, 0, AV_INPUT_BUFFER_PADDING_SIZE);
  878.  
  879.     // Separate out the AC3 substream from an HDMV combined TrueHD/AC3 PID
  880.     if (pes->sub_st && pes->stream_type == 0x83 && pes->extended_stream_id == 0x76)
  881.         pkt->stream_index = pes->sub_st->index;
  882.     else
  883.         pkt->stream_index = pes->st->index;
  884.     pkt->pts = pes->pts;
  885.     pkt->dts = pes->dts;
  886.     /* store position of first TS packet of this PES packet */
  887.     pkt->pos   = pes->ts_packet_pos;
  888.     pkt->flags = pes->flags;
  889.  
  890.     pes->buffer = NULL;
  891.     reset_pes_packet_state(pes);
  892. }
  893.  
  894. static uint64_t get_ts64(GetBitContext *gb, int bits)
  895. {
  896.     if (get_bits_left(gb) < bits)
  897.         return AV_NOPTS_VALUE;
  898.     return get_bits64(gb, bits);
  899. }
  900.  
  901. static int read_sl_header(PESContext *pes, SLConfigDescr *sl,
  902.                           const uint8_t *buf, int buf_size)
  903. {
  904.     GetBitContext gb;
  905.     int au_start_flag = 0, au_end_flag = 0, ocr_flag = 0, idle_flag = 0;
  906.     int padding_flag = 0, padding_bits = 0, inst_bitrate_flag = 0;
  907.     int dts_flag = -1, cts_flag = -1;
  908.     int64_t dts = AV_NOPTS_VALUE, cts = AV_NOPTS_VALUE;
  909.     uint8_t buf_padded[128 + AV_INPUT_BUFFER_PADDING_SIZE];
  910.     int buf_padded_size = FFMIN(buf_size, sizeof(buf_padded) - AV_INPUT_BUFFER_PADDING_SIZE);
  911.  
  912.     memcpy(buf_padded, buf, buf_padded_size);
  913.  
  914.     init_get_bits(&gb, buf_padded, buf_padded_size * 8);
  915.  
  916.     if (sl->use_au_start)
  917.         au_start_flag = get_bits1(&gb);
  918.     if (sl->use_au_end)
  919.         au_end_flag = get_bits1(&gb);
  920.     if (!sl->use_au_start && !sl->use_au_end)
  921.         au_start_flag = au_end_flag = 1;
  922.     if (sl->ocr_len > 0)
  923.         ocr_flag = get_bits1(&gb);
  924.     if (sl->use_idle)
  925.         idle_flag = get_bits1(&gb);
  926.     if (sl->use_padding)
  927.         padding_flag = get_bits1(&gb);
  928.     if (padding_flag)
  929.         padding_bits = get_bits(&gb, 3);
  930.  
  931.     if (!idle_flag && (!padding_flag || padding_bits != 0)) {
  932.         if (sl->packet_seq_num_len)
  933.             skip_bits_long(&gb, sl->packet_seq_num_len);
  934.         if (sl->degr_prior_len)
  935.             if (get_bits1(&gb))
  936.                 skip_bits(&gb, sl->degr_prior_len);
  937.         if (ocr_flag)
  938.             skip_bits_long(&gb, sl->ocr_len);
  939.         if (au_start_flag) {
  940.             if (sl->use_rand_acc_pt)
  941.                 get_bits1(&gb);
  942.             if (sl->au_seq_num_len > 0)
  943.                 skip_bits_long(&gb, sl->au_seq_num_len);
  944.             if (sl->use_timestamps) {
  945.                 dts_flag = get_bits1(&gb);
  946.                 cts_flag = get_bits1(&gb);
  947.             }
  948.         }
  949.         if (sl->inst_bitrate_len)
  950.             inst_bitrate_flag = get_bits1(&gb);
  951.         if (dts_flag == 1)
  952.             dts = get_ts64(&gb, sl->timestamp_len);
  953.         if (cts_flag == 1)
  954.             cts = get_ts64(&gb, sl->timestamp_len);
  955.         if (sl->au_len > 0)
  956.             skip_bits_long(&gb, sl->au_len);
  957.         if (inst_bitrate_flag)
  958.             skip_bits_long(&gb, sl->inst_bitrate_len);
  959.     }
  960.  
  961.     if (dts != AV_NOPTS_VALUE)
  962.         pes->dts = dts;
  963.     if (cts != AV_NOPTS_VALUE)
  964.         pes->pts = cts;
  965.  
  966.     if (sl->timestamp_len && sl->timestamp_res)
  967.         avpriv_set_pts_info(pes->st, sl->timestamp_len, 1, sl->timestamp_res);
  968.  
  969.     return (get_bits_count(&gb) + 7) >> 3;
  970. }
  971.  
  972. /* return non zero if a packet could be constructed */
  973. static int mpegts_push_data(MpegTSFilter *filter,
  974.                             const uint8_t *buf, int buf_size, int is_start,
  975.                             int64_t pos)
  976. {
  977.     PESContext *pes   = filter->u.pes_filter.opaque;
  978.     MpegTSContext *ts = pes->ts;
  979.     const uint8_t *p;
  980.     int len, code;
  981.  
  982.     if (!ts->pkt)
  983.         return 0;
  984.  
  985.     if (is_start) {
  986.         if (pes->state == MPEGTS_PAYLOAD && pes->data_index > 0) {
  987.             new_pes_packet(pes, ts->pkt);
  988.             ts->stop_parse = 1;
  989.         } else {
  990.             reset_pes_packet_state(pes);
  991.         }
  992.         pes->state         = MPEGTS_HEADER;
  993.         pes->ts_packet_pos = pos;
  994.     }
  995.     p = buf;
  996.     while (buf_size > 0) {
  997.         switch (pes->state) {
  998.         case MPEGTS_HEADER:
  999.             len = PES_START_SIZE - pes->data_index;
  1000.             if (len > buf_size)
  1001.                 len = buf_size;
  1002.             memcpy(pes->header + pes->data_index, p, len);
  1003.             pes->data_index += len;
  1004.             p += len;
  1005.             buf_size -= len;
  1006.             if (pes->data_index == PES_START_SIZE) {
  1007.                 /* we got all the PES or section header. We can now
  1008.                  * decide */
  1009.                 if (pes->header[0] == 0x00 && pes->header[1] == 0x00 &&
  1010.                     pes->header[2] == 0x01) {
  1011.                     /* it must be an mpeg2 PES stream */
  1012.                     code = pes->header[3] | 0x100;
  1013.                     av_log(pes->stream, AV_LOG_TRACE, "pid=%x pes_code=%#x\n", pes->pid,
  1014.                             code);
  1015.  
  1016.                     if ((pes->st && pes->st->discard == AVDISCARD_ALL &&
  1017.                          (!pes->sub_st ||
  1018.                           pes->sub_st->discard == AVDISCARD_ALL)) ||
  1019.                         code == 0x1be) /* padding_stream */
  1020.                         goto skip;
  1021.  
  1022.                     /* stream not present in PMT */
  1023.                     if (!pes->st) {
  1024.                         if (ts->skip_changes)
  1025.                             goto skip;
  1026.  
  1027.                         pes->st = avformat_new_stream(ts->stream, NULL);
  1028.                         if (!pes->st)
  1029.                             return AVERROR(ENOMEM);
  1030.                         pes->st->id = pes->pid;
  1031.                         mpegts_set_stream_info(pes->st, pes, 0, 0);
  1032.                     }
  1033.  
  1034.                     pes->total_size = AV_RB16(pes->header + 4);
  1035.                     /* NOTE: a zero total size means the PES size is
  1036.                      * unbounded */
  1037.                     if (!pes->total_size)
  1038.                         pes->total_size = MAX_PES_PAYLOAD;
  1039.  
  1040.                     /* allocate pes buffer */
  1041.                     pes->buffer = av_buffer_alloc(pes->total_size +
  1042.                                                   AV_INPUT_BUFFER_PADDING_SIZE);
  1043.                     if (!pes->buffer)
  1044.                         return AVERROR(ENOMEM);
  1045.  
  1046.                     if (code != 0x1bc && code != 0x1bf && /* program_stream_map, private_stream_2 */
  1047.                         code != 0x1f0 && code != 0x1f1 && /* ECM, EMM */
  1048.                         code != 0x1ff && code != 0x1f2 && /* program_stream_directory, DSMCC_stream */
  1049.                         code != 0x1f8) {                  /* ITU-T Rec. H.222.1 type E stream */
  1050.                         pes->state = MPEGTS_PESHEADER;
  1051.                         if (pes->st->codec->codec_id == AV_CODEC_ID_NONE && !pes->st->request_probe) {
  1052.                             av_log(pes->stream, AV_LOG_TRACE,
  1053.                                     "pid=%x stream_type=%x probing\n",
  1054.                                     pes->pid,
  1055.                                     pes->stream_type);
  1056.                             pes->st->request_probe = 1;
  1057.                         }
  1058.                     } else {
  1059.                         pes->pes_header_size = 6;
  1060.                         pes->state      = MPEGTS_PAYLOAD;
  1061.                         pes->data_index = 0;
  1062.                     }
  1063.                 } else {
  1064.                     /* otherwise, it should be a table */
  1065.                     /* skip packet */
  1066. skip:
  1067.                     pes->state = MPEGTS_SKIP;
  1068.                     continue;
  1069.                 }
  1070.             }
  1071.             break;
  1072.         /**********************************************/
  1073.         /* PES packing parsing */
  1074.         case MPEGTS_PESHEADER:
  1075.             len = PES_HEADER_SIZE - pes->data_index;
  1076.             if (len < 0)
  1077.                 return AVERROR_INVALIDDATA;
  1078.             if (len > buf_size)
  1079.                 len = buf_size;
  1080.             memcpy(pes->header + pes->data_index, p, len);
  1081.             pes->data_index += len;
  1082.             p += len;
  1083.             buf_size -= len;
  1084.             if (pes->data_index == PES_HEADER_SIZE) {
  1085.                 pes->pes_header_size = pes->header[8] + 9;
  1086.                 pes->state           = MPEGTS_PESHEADER_FILL;
  1087.             }
  1088.             break;
  1089.         case MPEGTS_PESHEADER_FILL:
  1090.             len = pes->pes_header_size - pes->data_index;
  1091.             if (len < 0)
  1092.                 return AVERROR_INVALIDDATA;
  1093.             if (len > buf_size)
  1094.                 len = buf_size;
  1095.             memcpy(pes->header + pes->data_index, p, len);
  1096.             pes->data_index += len;
  1097.             p += len;
  1098.             buf_size -= len;
  1099.             if (pes->data_index == pes->pes_header_size) {
  1100.                 const uint8_t *r;
  1101.                 unsigned int flags, pes_ext, skip;
  1102.  
  1103.                 flags = pes->header[7];
  1104.                 r = pes->header + 9;
  1105.                 pes->pts = AV_NOPTS_VALUE;
  1106.                 pes->dts = AV_NOPTS_VALUE;
  1107.                 if ((flags & 0xc0) == 0x80) {
  1108.                     pes->dts = pes->pts = ff_parse_pes_pts(r);
  1109.                     r += 5;
  1110.                 } else if ((flags & 0xc0) == 0xc0) {
  1111.                     pes->pts = ff_parse_pes_pts(r);
  1112.                     r += 5;
  1113.                     pes->dts = ff_parse_pes_pts(r);
  1114.                     r += 5;
  1115.                 }
  1116.                 pes->extended_stream_id = -1;
  1117.                 if (flags & 0x01) { /* PES extension */
  1118.                     pes_ext = *r++;
  1119.                     /* Skip PES private data, program packet sequence counter and P-STD buffer */
  1120.                     skip  = (pes_ext >> 4) & 0xb;
  1121.                     skip += skip & 0x9;
  1122.                     r    += skip;
  1123.                     if ((pes_ext & 0x41) == 0x01 &&
  1124.                         (r + 2) <= (pes->header + pes->pes_header_size)) {
  1125.                         /* PES extension 2 */
  1126.                         if ((r[0] & 0x7f) > 0 && (r[1] & 0x80) == 0)
  1127.                             pes->extended_stream_id = r[1];
  1128.                     }
  1129.                 }
  1130.  
  1131.                 /* we got the full header. We parse it and get the payload */
  1132.                 pes->state = MPEGTS_PAYLOAD;
  1133.                 pes->data_index = 0;
  1134.                 if (pes->stream_type == 0x12 && buf_size > 0) {
  1135.                     int sl_header_bytes = read_sl_header(pes, &pes->sl, p,
  1136.                                                          buf_size);
  1137.                     pes->pes_header_size += sl_header_bytes;
  1138.                     p += sl_header_bytes;
  1139.                     buf_size -= sl_header_bytes;
  1140.                 }
  1141.                 if (pes->stream_type == 0x15 && buf_size >= 5) {
  1142.                     /* skip metadata access unit header */
  1143.                     pes->pes_header_size += 5;
  1144.                     p += 5;
  1145.                     buf_size -= 5;
  1146.                 }
  1147.                 if (   pes->ts->fix_teletext_pts
  1148.                     && (   pes->st->codec->codec_id == AV_CODEC_ID_DVB_TELETEXT
  1149.                         || pes->st->codec->codec_id == AV_CODEC_ID_DVB_SUBTITLE)
  1150.                     ) {
  1151.                     AVProgram *p = NULL;
  1152.                     while ((p = av_find_program_from_stream(pes->stream, p, pes->st->index))) {
  1153.                         if (p->pcr_pid != -1 && p->discard != AVDISCARD_ALL) {
  1154.                             MpegTSFilter *f = pes->ts->pids[p->pcr_pid];
  1155.                             if (f) {
  1156.                                 AVStream *st = NULL;
  1157.                                 if (f->type == MPEGTS_PES) {
  1158.                                     PESContext *pcrpes = f->u.pes_filter.opaque;
  1159.                                     if (pcrpes)
  1160.                                         st = pcrpes->st;
  1161.                                 } else if (f->type == MPEGTS_PCR) {
  1162.                                     int i;
  1163.                                     for (i = 0; i < p->nb_stream_indexes; i++) {
  1164.                                         AVStream *pst = pes->stream->streams[p->stream_index[i]];
  1165.                                         if (pst->codec->codec_type == AVMEDIA_TYPE_VIDEO)
  1166.                                             st = pst;
  1167.                                     }
  1168.                                 }
  1169.                                 if (f->last_pcr != -1 && st && st->discard != AVDISCARD_ALL) {
  1170.                                     // teletext packets do not always have correct timestamps,
  1171.                                     // the standard says they should be handled after 40.6 ms at most,
  1172.                                     // and the pcr error to this packet should be no more than 100 ms.
  1173.                                     // TODO: we should interpolate the PCR, not just use the last one
  1174.                                     int64_t pcr = f->last_pcr / 300;
  1175.                                     pes->st->pts_wrap_reference = st->pts_wrap_reference;
  1176.                                     pes->st->pts_wrap_behavior = st->pts_wrap_behavior;
  1177.                                     if (pes->dts == AV_NOPTS_VALUE || pes->dts < pcr) {
  1178.                                         pes->pts = pes->dts = pcr;
  1179.                                     } else if (pes->st->codec->codec_id == AV_CODEC_ID_DVB_TELETEXT &&
  1180.                                                pes->dts > pcr + 3654 + 9000) {
  1181.                                         pes->pts = pes->dts = pcr + 3654 + 9000;
  1182.                                     } else if (pes->st->codec->codec_id == AV_CODEC_ID_DVB_SUBTITLE &&
  1183.                                                pes->dts > pcr + 10*90000) { //10sec
  1184.                                         pes->pts = pes->dts = pcr + 3654 + 9000;
  1185.                                     }
  1186.                                     break;
  1187.                                 }
  1188.                             }
  1189.                         }
  1190.                     }
  1191.                 }
  1192.             }
  1193.             break;
  1194.         case MPEGTS_PAYLOAD:
  1195.             if (pes->buffer) {
  1196.                 if (pes->data_index > 0 &&
  1197.                     pes->data_index + buf_size > pes->total_size) {
  1198.                     new_pes_packet(pes, ts->pkt);
  1199.                     pes->total_size = MAX_PES_PAYLOAD;
  1200.                     pes->buffer = av_buffer_alloc(pes->total_size +
  1201.                                                   AV_INPUT_BUFFER_PADDING_SIZE);
  1202.                     if (!pes->buffer)
  1203.                         return AVERROR(ENOMEM);
  1204.                     ts->stop_parse = 1;
  1205.                 } else if (pes->data_index == 0 &&
  1206.                            buf_size > pes->total_size) {
  1207.                     // pes packet size is < ts size packet and pes data is padded with 0xff
  1208.                     // not sure if this is legal in ts but see issue #2392
  1209.                     buf_size = pes->total_size;
  1210.                 }
  1211.                 memcpy(pes->buffer->data + pes->data_index, p, buf_size);
  1212.                 pes->data_index += buf_size;
  1213.                 /* emit complete packets with known packet size
  1214.                  * decreases demuxer delay for infrequent packets like subtitles from
  1215.                  * a couple of seconds to milliseconds for properly muxed files.
  1216.                  * total_size is the number of bytes following pes_packet_length
  1217.                  * in the pes header, i.e. not counting the first PES_START_SIZE bytes */
  1218.                 if (!ts->stop_parse && pes->total_size < MAX_PES_PAYLOAD &&
  1219.                     pes->pes_header_size + pes->data_index == pes->total_size + PES_START_SIZE) {
  1220.                     ts->stop_parse = 1;
  1221.                     new_pes_packet(pes, ts->pkt);
  1222.                 }
  1223.             }
  1224.             buf_size = 0;
  1225.             break;
  1226.         case MPEGTS_SKIP:
  1227.             buf_size = 0;
  1228.             break;
  1229.         }
  1230.     }
  1231.  
  1232.     return 0;
  1233. }
  1234.  
  1235. static PESContext *add_pes_stream(MpegTSContext *ts, int pid, int pcr_pid)
  1236. {
  1237.     MpegTSFilter *tss;
  1238.     PESContext *pes;
  1239.  
  1240.     /* if no pid found, then add a pid context */
  1241.     pes = av_mallocz(sizeof(PESContext));
  1242.     if (!pes)
  1243.         return 0;
  1244.     pes->ts      = ts;
  1245.     pes->stream  = ts->stream;
  1246.     pes->pid     = pid;
  1247.     pes->pcr_pid = pcr_pid;
  1248.     pes->state   = MPEGTS_SKIP;
  1249.     pes->pts     = AV_NOPTS_VALUE;
  1250.     pes->dts     = AV_NOPTS_VALUE;
  1251.     tss          = mpegts_open_pes_filter(ts, pid, mpegts_push_data, pes);
  1252.     if (!tss) {
  1253.         av_free(pes);
  1254.         return 0;
  1255.     }
  1256.     return pes;
  1257. }
  1258.  
  1259. #define MAX_LEVEL 4
  1260. typedef struct MP4DescrParseContext {
  1261.     AVFormatContext *s;
  1262.     AVIOContext pb;
  1263.     Mp4Descr *descr;
  1264.     Mp4Descr *active_descr;
  1265.     int descr_count;
  1266.     int max_descr_count;
  1267.     int level;
  1268.     int predefined_SLConfigDescriptor_seen;
  1269. } MP4DescrParseContext;
  1270.  
  1271. static int init_MP4DescrParseContext(MP4DescrParseContext *d, AVFormatContext *s,
  1272.                                      const uint8_t *buf, unsigned size,
  1273.                                      Mp4Descr *descr, int max_descr_count)
  1274. {
  1275.     int ret;
  1276.     if (size > (1 << 30))
  1277.         return AVERROR_INVALIDDATA;
  1278.  
  1279.     if ((ret = ffio_init_context(&d->pb, (unsigned char *)buf, size, 0,
  1280.                                  NULL, NULL, NULL, NULL)) < 0)
  1281.         return ret;
  1282.  
  1283.     d->s               = s;
  1284.     d->level           = 0;
  1285.     d->descr_count     = 0;
  1286.     d->descr           = descr;
  1287.     d->active_descr    = NULL;
  1288.     d->max_descr_count = max_descr_count;
  1289.  
  1290.     return 0;
  1291. }
  1292.  
  1293. static void update_offsets(AVIOContext *pb, int64_t *off, int *len)
  1294. {
  1295.     int64_t new_off = avio_tell(pb);
  1296.     (*len) -= new_off - *off;
  1297.     *off    = new_off;
  1298. }
  1299.  
  1300. static int parse_mp4_descr(MP4DescrParseContext *d, int64_t off, int len,
  1301.                            int target_tag);
  1302.  
  1303. static int parse_mp4_descr_arr(MP4DescrParseContext *d, int64_t off, int len)
  1304. {
  1305.     while (len > 0) {
  1306.         int ret = parse_mp4_descr(d, off, len, 0);
  1307.         if (ret < 0)
  1308.             return ret;
  1309.         update_offsets(&d->pb, &off, &len);
  1310.     }
  1311.     return 0;
  1312. }
  1313.  
  1314. static int parse_MP4IODescrTag(MP4DescrParseContext *d, int64_t off, int len)
  1315. {
  1316.     avio_rb16(&d->pb); // ID
  1317.     avio_r8(&d->pb);
  1318.     avio_r8(&d->pb);
  1319.     avio_r8(&d->pb);
  1320.     avio_r8(&d->pb);
  1321.     avio_r8(&d->pb);
  1322.     update_offsets(&d->pb, &off, &len);
  1323.     return parse_mp4_descr_arr(d, off, len);
  1324. }
  1325.  
  1326. static int parse_MP4ODescrTag(MP4DescrParseContext *d, int64_t off, int len)
  1327. {
  1328.     int id_flags;
  1329.     if (len < 2)
  1330.         return 0;
  1331.     id_flags = avio_rb16(&d->pb);
  1332.     if (!(id_flags & 0x0020)) { // URL_Flag
  1333.         update_offsets(&d->pb, &off, &len);
  1334.         return parse_mp4_descr_arr(d, off, len); // ES_Descriptor[]
  1335.     } else {
  1336.         return 0;
  1337.     }
  1338. }
  1339.  
  1340. static int parse_MP4ESDescrTag(MP4DescrParseContext *d, int64_t off, int len)
  1341. {
  1342.     int es_id = 0;
  1343.     if (d->descr_count >= d->max_descr_count)
  1344.         return AVERROR_INVALIDDATA;
  1345.     ff_mp4_parse_es_descr(&d->pb, &es_id);
  1346.     d->active_descr = d->descr + (d->descr_count++);
  1347.  
  1348.     d->active_descr->es_id = es_id;
  1349.     update_offsets(&d->pb, &off, &len);
  1350.     parse_mp4_descr(d, off, len, MP4DecConfigDescrTag);
  1351.     update_offsets(&d->pb, &off, &len);
  1352.     if (len > 0)
  1353.         parse_mp4_descr(d, off, len, MP4SLDescrTag);
  1354.     d->active_descr = NULL;
  1355.     return 0;
  1356. }
  1357.  
  1358. static int parse_MP4DecConfigDescrTag(MP4DescrParseContext *d, int64_t off,
  1359.                                       int len)
  1360. {
  1361.     Mp4Descr *descr = d->active_descr;
  1362.     if (!descr)
  1363.         return AVERROR_INVALIDDATA;
  1364.     d->active_descr->dec_config_descr = av_malloc(len);
  1365.     if (!descr->dec_config_descr)
  1366.         return AVERROR(ENOMEM);
  1367.     descr->dec_config_descr_len = len;
  1368.     avio_read(&d->pb, descr->dec_config_descr, len);
  1369.     return 0;
  1370. }
  1371.  
  1372. static int parse_MP4SLDescrTag(MP4DescrParseContext *d, int64_t off, int len)
  1373. {
  1374.     Mp4Descr *descr = d->active_descr;
  1375.     int predefined;
  1376.     if (!descr)
  1377.         return AVERROR_INVALIDDATA;
  1378.  
  1379.     predefined = avio_r8(&d->pb);
  1380.     if (!predefined) {
  1381.         int lengths;
  1382.         int flags = avio_r8(&d->pb);
  1383.         descr->sl.use_au_start    = !!(flags & 0x80);
  1384.         descr->sl.use_au_end      = !!(flags & 0x40);
  1385.         descr->sl.use_rand_acc_pt = !!(flags & 0x20);
  1386.         descr->sl.use_padding     = !!(flags & 0x08);
  1387.         descr->sl.use_timestamps  = !!(flags & 0x04);
  1388.         descr->sl.use_idle        = !!(flags & 0x02);
  1389.         descr->sl.timestamp_res   = avio_rb32(&d->pb);
  1390.         avio_rb32(&d->pb);
  1391.         descr->sl.timestamp_len      = avio_r8(&d->pb);
  1392.         if (descr->sl.timestamp_len > 64) {
  1393.             avpriv_request_sample(NULL, "timestamp_len > 64");
  1394.             descr->sl.timestamp_len = 64;
  1395.             return AVERROR_PATCHWELCOME;
  1396.         }
  1397.         descr->sl.ocr_len            = avio_r8(&d->pb);
  1398.         descr->sl.au_len             = avio_r8(&d->pb);
  1399.         descr->sl.inst_bitrate_len   = avio_r8(&d->pb);
  1400.         lengths                      = avio_rb16(&d->pb);
  1401.         descr->sl.degr_prior_len     = lengths >> 12;
  1402.         descr->sl.au_seq_num_len     = (lengths >> 7) & 0x1f;
  1403.         descr->sl.packet_seq_num_len = (lengths >> 2) & 0x1f;
  1404.     } else if (!d->predefined_SLConfigDescriptor_seen){
  1405.         avpriv_report_missing_feature(d->s, "Predefined SLConfigDescriptor");
  1406.         d->predefined_SLConfigDescriptor_seen = 1;
  1407.     }
  1408.     return 0;
  1409. }
  1410.  
  1411. static int parse_mp4_descr(MP4DescrParseContext *d, int64_t off, int len,
  1412.                            int target_tag)
  1413. {
  1414.     int tag;
  1415.     int len1 = ff_mp4_read_descr(d->s, &d->pb, &tag);
  1416.     update_offsets(&d->pb, &off, &len);
  1417.     if (len < 0 || len1 > len || len1 <= 0) {
  1418.         av_log(d->s, AV_LOG_ERROR,
  1419.                "Tag %x length violation new length %d bytes remaining %d\n",
  1420.                tag, len1, len);
  1421.         return AVERROR_INVALIDDATA;
  1422.     }
  1423.  
  1424.     if (d->level++ >= MAX_LEVEL) {
  1425.         av_log(d->s, AV_LOG_ERROR, "Maximum MP4 descriptor level exceeded\n");
  1426.         goto done;
  1427.     }
  1428.  
  1429.     if (target_tag && tag != target_tag) {
  1430.         av_log(d->s, AV_LOG_ERROR, "Found tag %x expected %x\n", tag,
  1431.                target_tag);
  1432.         goto done;
  1433.     }
  1434.  
  1435.     switch (tag) {
  1436.     case MP4IODescrTag:
  1437.         parse_MP4IODescrTag(d, off, len1);
  1438.         break;
  1439.     case MP4ODescrTag:
  1440.         parse_MP4ODescrTag(d, off, len1);
  1441.         break;
  1442.     case MP4ESDescrTag:
  1443.         parse_MP4ESDescrTag(d, off, len1);
  1444.         break;
  1445.     case MP4DecConfigDescrTag:
  1446.         parse_MP4DecConfigDescrTag(d, off, len1);
  1447.         break;
  1448.     case MP4SLDescrTag:
  1449.         parse_MP4SLDescrTag(d, off, len1);
  1450.         break;
  1451.     }
  1452.  
  1453.  
  1454. done:
  1455.     d->level--;
  1456.     avio_seek(&d->pb, off + len1, SEEK_SET);
  1457.     return 0;
  1458. }
  1459.  
  1460. static int mp4_read_iods(AVFormatContext *s, const uint8_t *buf, unsigned size,
  1461.                          Mp4Descr *descr, int *descr_count, int max_descr_count)
  1462. {
  1463.     MP4DescrParseContext d;
  1464.     int ret;
  1465.  
  1466.     ret = init_MP4DescrParseContext(&d, s, buf, size, descr, max_descr_count);
  1467.     if (ret < 0)
  1468.         return ret;
  1469.  
  1470.     ret = parse_mp4_descr(&d, avio_tell(&d.pb), size, MP4IODescrTag);
  1471.  
  1472.     *descr_count = d.descr_count;
  1473.     return ret;
  1474. }
  1475.  
  1476. static int mp4_read_od(AVFormatContext *s, const uint8_t *buf, unsigned size,
  1477.                        Mp4Descr *descr, int *descr_count, int max_descr_count)
  1478. {
  1479.     MP4DescrParseContext d;
  1480.     int ret;
  1481.  
  1482.     ret = init_MP4DescrParseContext(&d, s, buf, size, descr, max_descr_count);
  1483.     if (ret < 0)
  1484.         return ret;
  1485.  
  1486.     ret = parse_mp4_descr_arr(&d, avio_tell(&d.pb), size);
  1487.  
  1488.     *descr_count = d.descr_count;
  1489.     return ret;
  1490. }
  1491.  
  1492. static void m4sl_cb(MpegTSFilter *filter, const uint8_t *section,
  1493.                     int section_len)
  1494. {
  1495.     MpegTSContext *ts = filter->u.section_filter.opaque;
  1496.     MpegTSSectionFilter *tssf = &filter->u.section_filter;
  1497.     SectionHeader h;
  1498.     const uint8_t *p, *p_end;
  1499.     AVIOContext pb;
  1500.     int mp4_descr_count = 0;
  1501.     Mp4Descr mp4_descr[MAX_MP4_DESCR_COUNT] = { { 0 } };
  1502.     int i, pid;
  1503.     AVFormatContext *s = ts->stream;
  1504.  
  1505.     p_end = section + section_len - 4;
  1506.     p = section;
  1507.     if (parse_section_header(&h, &p, p_end) < 0)
  1508.         return;
  1509.     if (h.tid != M4OD_TID)
  1510.         return;
  1511.     if (skip_identical(&h, tssf))
  1512.         return;
  1513.  
  1514.     mp4_read_od(s, p, (unsigned) (p_end - p), mp4_descr, &mp4_descr_count,
  1515.                 MAX_MP4_DESCR_COUNT);
  1516.  
  1517.     for (pid = 0; pid < NB_PID_MAX; pid++) {
  1518.         if (!ts->pids[pid])
  1519.             continue;
  1520.         for (i = 0; i < mp4_descr_count; i++) {
  1521.             PESContext *pes;
  1522.             AVStream *st;
  1523.             if (ts->pids[pid]->es_id != mp4_descr[i].es_id)
  1524.                 continue;
  1525.             if (ts->pids[pid]->type != MPEGTS_PES) {
  1526.                 av_log(s, AV_LOG_ERROR, "pid %x is not PES\n", pid);
  1527.                 continue;
  1528.             }
  1529.             pes = ts->pids[pid]->u.pes_filter.opaque;
  1530.             st  = pes->st;
  1531.             if (!st)
  1532.                 continue;
  1533.  
  1534.             pes->sl = mp4_descr[i].sl;
  1535.  
  1536.             ffio_init_context(&pb, mp4_descr[i].dec_config_descr,
  1537.                               mp4_descr[i].dec_config_descr_len, 0,
  1538.                               NULL, NULL, NULL, NULL);
  1539.             ff_mp4_read_dec_config_descr(s, st, &pb);
  1540.             if (st->codec->codec_id == AV_CODEC_ID_AAC &&
  1541.                 st->codec->extradata_size > 0)
  1542.                 st->need_parsing = 0;
  1543.             if (st->codec->codec_id == AV_CODEC_ID_H264 &&
  1544.                 st->codec->extradata_size > 0)
  1545.                 st->need_parsing = 0;
  1546.  
  1547.             if (st->codec->codec_id <= AV_CODEC_ID_NONE) {
  1548.                 // do nothing
  1549.             } else if (st->codec->codec_id < AV_CODEC_ID_FIRST_AUDIO)
  1550.                 st->codec->codec_type = AVMEDIA_TYPE_VIDEO;
  1551.             else if (st->codec->codec_id < AV_CODEC_ID_FIRST_SUBTITLE)
  1552.                 st->codec->codec_type = AVMEDIA_TYPE_AUDIO;
  1553.             else if (st->codec->codec_id < AV_CODEC_ID_FIRST_UNKNOWN)
  1554.                 st->codec->codec_type = AVMEDIA_TYPE_SUBTITLE;
  1555.         }
  1556.     }
  1557.     for (i = 0; i < mp4_descr_count; i++)
  1558.         av_free(mp4_descr[i].dec_config_descr);
  1559. }
  1560.  
  1561. static const uint8_t opus_coupled_stream_cnt[9] = {
  1562.     1, 0, 1, 1, 2, 2, 2, 3, 3
  1563. };
  1564.  
  1565. static const uint8_t opus_stream_cnt[9] = {
  1566.     1, 1, 1, 2, 2, 3, 4, 4, 5,
  1567. };
  1568.  
  1569. static const uint8_t opus_channel_map[8][8] = {
  1570.     { 0 },
  1571.     { 0,1 },
  1572.     { 0,2,1 },
  1573.     { 0,1,2,3 },
  1574.     { 0,4,1,2,3 },
  1575.     { 0,4,1,2,3,5 },
  1576.     { 0,4,1,2,3,5,6 },
  1577.     { 0,6,1,2,3,4,5,7 },
  1578. };
  1579.  
  1580. int ff_parse_mpeg2_descriptor(AVFormatContext *fc, AVStream *st, int stream_type,
  1581.                               const uint8_t **pp, const uint8_t *desc_list_end,
  1582.                               Mp4Descr *mp4_descr, int mp4_descr_count, int pid,
  1583.                               MpegTSContext *ts)
  1584. {
  1585.     const uint8_t *desc_end;
  1586.     int desc_len, desc_tag, desc_es_id, ext_desc_tag, channels, channel_config_code;
  1587.     char language[252];
  1588.     int i;
  1589.  
  1590.     desc_tag = get8(pp, desc_list_end);
  1591.     if (desc_tag < 0)
  1592.         return AVERROR_INVALIDDATA;
  1593.     desc_len = get8(pp, desc_list_end);
  1594.     if (desc_len < 0)
  1595.         return AVERROR_INVALIDDATA;
  1596.     desc_end = *pp + desc_len;
  1597.     if (desc_end > desc_list_end)
  1598.         return AVERROR_INVALIDDATA;
  1599.  
  1600.     av_log(fc, AV_LOG_TRACE, "tag: 0x%02x len=%d\n", desc_tag, desc_len);
  1601.  
  1602.     if ((st->codec->codec_id == AV_CODEC_ID_NONE || st->request_probe > 0) &&
  1603.         stream_type == STREAM_TYPE_PRIVATE_DATA)
  1604.         mpegts_find_stream_type(st, desc_tag, DESC_types);
  1605.  
  1606.     switch (desc_tag) {
  1607.     case 0x1E: /* SL descriptor */
  1608.         desc_es_id = get16(pp, desc_end);
  1609.         if (desc_es_id < 0)
  1610.             break;
  1611.         if (ts && ts->pids[pid])
  1612.             ts->pids[pid]->es_id = desc_es_id;
  1613.         for (i = 0; i < mp4_descr_count; i++)
  1614.             if (mp4_descr[i].dec_config_descr_len &&
  1615.                 mp4_descr[i].es_id == desc_es_id) {
  1616.                 AVIOContext pb;
  1617.                 ffio_init_context(&pb, mp4_descr[i].dec_config_descr,
  1618.                                   mp4_descr[i].dec_config_descr_len, 0,
  1619.                                   NULL, NULL, NULL, NULL);
  1620.                 ff_mp4_read_dec_config_descr(fc, st, &pb);
  1621.                 if (st->codec->codec_id == AV_CODEC_ID_AAC &&
  1622.                     st->codec->extradata_size > 0)
  1623.                     st->need_parsing = 0;
  1624.                 if (st->codec->codec_id == AV_CODEC_ID_MPEG4SYSTEMS)
  1625.                     mpegts_open_section_filter(ts, pid, m4sl_cb, ts, 1);
  1626.             }
  1627.         break;
  1628.     case 0x1F: /* FMC descriptor */
  1629.         if (get16(pp, desc_end) < 0)
  1630.             break;
  1631.         if (mp4_descr_count > 0 &&
  1632.             (st->codec->codec_id == AV_CODEC_ID_AAC_LATM ||
  1633.              (st->request_probe == 0 && st->codec->codec_id == AV_CODEC_ID_NONE) ||
  1634.              st->request_probe > 0) &&
  1635.             mp4_descr->dec_config_descr_len && mp4_descr->es_id == pid) {
  1636.             AVIOContext pb;
  1637.             ffio_init_context(&pb, mp4_descr->dec_config_descr,
  1638.                               mp4_descr->dec_config_descr_len, 0,
  1639.                               NULL, NULL, NULL, NULL);
  1640.             ff_mp4_read_dec_config_descr(fc, st, &pb);
  1641.             if (st->codec->codec_id == AV_CODEC_ID_AAC &&
  1642.                 st->codec->extradata_size > 0) {
  1643.                 st->request_probe = st->need_parsing = 0;
  1644.                 st->codec->codec_type = AVMEDIA_TYPE_AUDIO;
  1645.             }
  1646.         }
  1647.         break;
  1648.     case 0x56: /* DVB teletext descriptor */
  1649.         {
  1650.             uint8_t *extradata = NULL;
  1651.             int language_count = desc_len / 5;
  1652.  
  1653.             if (desc_len > 0 && desc_len % 5 != 0)
  1654.                 return AVERROR_INVALIDDATA;
  1655.  
  1656.             if (language_count > 0) {
  1657.                 /* 4 bytes per language code (3 bytes) with comma or NUL byte should fit language buffer */
  1658.                 av_assert0(language_count <= sizeof(language) / 4);
  1659.  
  1660.                 if (st->codec->extradata == NULL) {
  1661.                     if (ff_alloc_extradata(st->codec, language_count * 2)) {
  1662.                         return AVERROR(ENOMEM);
  1663.                     }
  1664.                 }
  1665.  
  1666.                if (st->codec->extradata_size < language_count * 2)
  1667.                    return AVERROR_INVALIDDATA;
  1668.  
  1669.                extradata = st->codec->extradata;
  1670.  
  1671.                 for (i = 0; i < language_count; i++) {
  1672.                     language[i * 4 + 0] = get8(pp, desc_end);
  1673.                     language[i * 4 + 1] = get8(pp, desc_end);
  1674.                     language[i * 4 + 2] = get8(pp, desc_end);
  1675.                     language[i * 4 + 3] = ',';
  1676.  
  1677.                     memcpy(extradata, *pp, 2);
  1678.                     extradata += 2;
  1679.  
  1680.                     *pp += 2;
  1681.                 }
  1682.  
  1683.                 language[i * 4 - 1] = 0;
  1684.                 av_dict_set(&st->metadata, "language", language, 0);
  1685.             }
  1686.         }
  1687.         break;
  1688.     case 0x59: /* subtitling descriptor */
  1689.         {
  1690.             /* 8 bytes per DVB subtitle substream data:
  1691.              * ISO_639_language_code (3 bytes),
  1692.              * subtitling_type (1 byte),
  1693.              * composition_page_id (2 bytes),
  1694.              * ancillary_page_id (2 bytes) */
  1695.             int language_count = desc_len / 8;
  1696.  
  1697.             if (desc_len > 0 && desc_len % 8 != 0)
  1698.                 return AVERROR_INVALIDDATA;
  1699.  
  1700.             if (language_count > 1) {
  1701.                 avpriv_request_sample(fc, "DVB subtitles with multiple languages");
  1702.             }
  1703.  
  1704.             if (language_count > 0) {
  1705.                 uint8_t *extradata;
  1706.  
  1707.                 /* 4 bytes per language code (3 bytes) with comma or NUL byte should fit language buffer */
  1708.                 av_assert0(language_count <= sizeof(language) / 4);
  1709.  
  1710.                 if (st->codec->extradata == NULL) {
  1711.                     if (ff_alloc_extradata(st->codec, language_count * 5)) {
  1712.                         return AVERROR(ENOMEM);
  1713.                     }
  1714.                 }
  1715.  
  1716.                 if (st->codec->extradata_size < language_count * 5)
  1717.                     return AVERROR_INVALIDDATA;
  1718.  
  1719.                 extradata = st->codec->extradata;
  1720.  
  1721.                 for (i = 0; i < language_count; i++) {
  1722.                     language[i * 4 + 0] = get8(pp, desc_end);
  1723.                     language[i * 4 + 1] = get8(pp, desc_end);
  1724.                     language[i * 4 + 2] = get8(pp, desc_end);
  1725.                     language[i * 4 + 3] = ',';
  1726.  
  1727.                     /* hearing impaired subtitles detection using subtitling_type */
  1728.                     switch (*pp[0]) {
  1729.                     case 0x20: /* DVB subtitles (for the hard of hearing) with no monitor aspect ratio criticality */
  1730.                     case 0x21: /* DVB subtitles (for the hard of hearing) for display on 4:3 aspect ratio monitor */
  1731.                     case 0x22: /* DVB subtitles (for the hard of hearing) for display on 16:9 aspect ratio monitor */
  1732.                     case 0x23: /* DVB subtitles (for the hard of hearing) for display on 2.21:1 aspect ratio monitor */
  1733.                     case 0x24: /* DVB subtitles (for the hard of hearing) for display on a high definition monitor */
  1734.                     case 0x25: /* DVB subtitles (for the hard of hearing) with plano-stereoscopic disparity for display on a high definition monitor */
  1735.                         st->disposition |= AV_DISPOSITION_HEARING_IMPAIRED;
  1736.                         break;
  1737.                     }
  1738.  
  1739.                     extradata[4] = get8(pp, desc_end); /* subtitling_type */
  1740.                     memcpy(extradata, *pp, 4); /* composition_page_id and ancillary_page_id */
  1741.                     extradata += 5;
  1742.  
  1743.                     *pp += 4;
  1744.                 }
  1745.  
  1746.                 language[i * 4 - 1] = 0;
  1747.                 av_dict_set(&st->metadata, "language", language, 0);
  1748.             }
  1749.         }
  1750.         break;
  1751.     case 0x0a: /* ISO 639 language descriptor */
  1752.         for (i = 0; i + 4 <= desc_len; i += 4) {
  1753.             language[i + 0] = get8(pp, desc_end);
  1754.             language[i + 1] = get8(pp, desc_end);
  1755.             language[i + 2] = get8(pp, desc_end);
  1756.             language[i + 3] = ',';
  1757.             switch (get8(pp, desc_end)) {
  1758.             case 0x01:
  1759.                 st->disposition |= AV_DISPOSITION_CLEAN_EFFECTS;
  1760.                 break;
  1761.             case 0x02:
  1762.                 st->disposition |= AV_DISPOSITION_HEARING_IMPAIRED;
  1763.                 break;
  1764.             case 0x03:
  1765.                 st->disposition |= AV_DISPOSITION_VISUAL_IMPAIRED;
  1766.                 break;
  1767.             }
  1768.         }
  1769.         if (i && language[0]) {
  1770.             language[i - 1] = 0;
  1771.             av_dict_set(&st->metadata, "language", language, 0);
  1772.         }
  1773.         break;
  1774.     case 0x05: /* registration descriptor */
  1775.         st->codec->codec_tag = bytestream_get_le32(pp);
  1776.         av_log(fc, AV_LOG_TRACE, "reg_desc=%.4s\n", (char *)&st->codec->codec_tag);
  1777.         if (st->codec->codec_id == AV_CODEC_ID_NONE || st->request_probe > 0)
  1778.             mpegts_find_stream_type(st, st->codec->codec_tag, REGD_types);
  1779.         break;
  1780.     case 0x52: /* stream identifier descriptor */
  1781.         st->stream_identifier = 1 + get8(pp, desc_end);
  1782.         break;
  1783.     case 0x26: /* metadata descriptor */
  1784.         if (get16(pp, desc_end) == 0xFFFF)
  1785.             *pp += 4;
  1786.         if (get8(pp, desc_end) == 0xFF) {
  1787.             st->codec->codec_tag = bytestream_get_le32(pp);
  1788.             if (st->codec->codec_id == AV_CODEC_ID_NONE)
  1789.                 mpegts_find_stream_type(st, st->codec->codec_tag, METADATA_types);
  1790.         }
  1791.         break;
  1792.     case 0x7f: /* DVB extension descriptor */
  1793.         ext_desc_tag = get8(pp, desc_end);
  1794.         if (ext_desc_tag < 0)
  1795.             return AVERROR_INVALIDDATA;
  1796.         if (st->codec->codec_id == AV_CODEC_ID_OPUS &&
  1797.             ext_desc_tag == 0x80) { /* User defined (provisional Opus) */
  1798.             if (!st->codec->extradata) {
  1799.                 st->codec->extradata = av_mallocz(sizeof(opus_default_extradata) +
  1800.                                                   AV_INPUT_BUFFER_PADDING_SIZE);
  1801.                 if (!st->codec->extradata)
  1802.                     return AVERROR(ENOMEM);
  1803.  
  1804.                 st->codec->extradata_size = sizeof(opus_default_extradata);
  1805.                 memcpy(st->codec->extradata, opus_default_extradata, sizeof(opus_default_extradata));
  1806.  
  1807.                 channel_config_code = get8(pp, desc_end);
  1808.                 if (channel_config_code < 0)
  1809.                     return AVERROR_INVALIDDATA;
  1810.                 if (channel_config_code <= 0x8) {
  1811.                     st->codec->extradata[9]  = channels = channel_config_code ? channel_config_code : 2;
  1812.                     st->codec->extradata[18] = channel_config_code ? (channels > 2) : /* Dual Mono */ 255;
  1813.                     st->codec->extradata[19] = opus_stream_cnt[channel_config_code];
  1814.                     st->codec->extradata[20] = opus_coupled_stream_cnt[channel_config_code];
  1815.                     memcpy(&st->codec->extradata[21], opus_channel_map[channels - 1], channels);
  1816.                 } else {
  1817.                     avpriv_request_sample(fc, "Opus in MPEG-TS - channel_config_code > 0x8");
  1818.                 }
  1819.                 st->need_parsing = AVSTREAM_PARSE_FULL;
  1820.             }
  1821.         }
  1822.         break;
  1823.     default:
  1824.         break;
  1825.     }
  1826.     *pp = desc_end;
  1827.     return 0;
  1828. }
  1829.  
  1830. static void pmt_cb(MpegTSFilter *filter, const uint8_t *section, int section_len)
  1831. {
  1832.     MpegTSContext *ts = filter->u.section_filter.opaque;
  1833.     MpegTSSectionFilter *tssf = &filter->u.section_filter;
  1834.     SectionHeader h1, *h = &h1;
  1835.     PESContext *pes;
  1836.     AVStream *st;
  1837.     const uint8_t *p, *p_end, *desc_list_end;
  1838.     int program_info_length, pcr_pid, pid, stream_type;
  1839.     int desc_list_len;
  1840.     uint32_t prog_reg_desc = 0; /* registration descriptor */
  1841.  
  1842.     int mp4_descr_count = 0;
  1843.     Mp4Descr mp4_descr[MAX_MP4_DESCR_COUNT] = { { 0 } };
  1844.     int i;
  1845.  
  1846.     av_log(ts->stream, AV_LOG_TRACE, "PMT: len %i\n", section_len);
  1847.     hex_dump_debug(ts->stream, section, section_len);
  1848.  
  1849.     p_end = section + section_len - 4;
  1850.     p = section;
  1851.     if (parse_section_header(h, &p, p_end) < 0)
  1852.         return;
  1853.     if (skip_identical(h, tssf))
  1854.         return;
  1855.  
  1856.     av_log(ts->stream, AV_LOG_TRACE, "sid=0x%x sec_num=%d/%d version=%d\n",
  1857.             h->id, h->sec_num, h->last_sec_num, h->version);
  1858.  
  1859.     if (h->tid != PMT_TID)
  1860.         return;
  1861.     if (!ts->scan_all_pmts && ts->skip_changes)
  1862.         return;
  1863.  
  1864.     if (!ts->skip_clear)
  1865.         clear_program(ts, h->id);
  1866.  
  1867.     pcr_pid = get16(&p, p_end);
  1868.     if (pcr_pid < 0)
  1869.         return;
  1870.     pcr_pid &= 0x1fff;
  1871.     add_pid_to_pmt(ts, h->id, pcr_pid);
  1872.     set_pcr_pid(ts->stream, h->id, pcr_pid);
  1873.  
  1874.     av_log(ts->stream, AV_LOG_TRACE, "pcr_pid=0x%x\n", pcr_pid);
  1875.  
  1876.     program_info_length = get16(&p, p_end);
  1877.     if (program_info_length < 0)
  1878.         return;
  1879.     program_info_length &= 0xfff;
  1880.     while (program_info_length >= 2) {
  1881.         uint8_t tag, len;
  1882.         tag = get8(&p, p_end);
  1883.         len = get8(&p, p_end);
  1884.  
  1885.         av_log(ts->stream, AV_LOG_TRACE, "program tag: 0x%02x len=%d\n", tag, len);
  1886.  
  1887.         if (len > program_info_length - 2)
  1888.             // something else is broken, exit the program_descriptors_loop
  1889.             break;
  1890.         program_info_length -= len + 2;
  1891.         if (tag == 0x1d) { // IOD descriptor
  1892.             get8(&p, p_end); // scope
  1893.             get8(&p, p_end); // label
  1894.             len -= 2;
  1895.             mp4_read_iods(ts->stream, p, len, mp4_descr + mp4_descr_count,
  1896.                           &mp4_descr_count, MAX_MP4_DESCR_COUNT);
  1897.         } else if (tag == 0x05 && len >= 4) { // registration descriptor
  1898.             prog_reg_desc = bytestream_get_le32(&p);
  1899.             len -= 4;
  1900.         }
  1901.         p += len;
  1902.     }
  1903.     p += program_info_length;
  1904.     if (p >= p_end)
  1905.         goto out;
  1906.  
  1907.     // stop parsing after pmt, we found header
  1908.     if (!ts->stream->nb_streams)
  1909.         ts->stop_parse = 2;
  1910.  
  1911.     set_pmt_found(ts, h->id);
  1912.  
  1913.  
  1914.     for (;;) {
  1915.         st = 0;
  1916.         pes = NULL;
  1917.         stream_type = get8(&p, p_end);
  1918.         if (stream_type < 0)
  1919.             break;
  1920.         pid = get16(&p, p_end);
  1921.         if (pid < 0)
  1922.             goto out;
  1923.         pid &= 0x1fff;
  1924.         if (pid == ts->current_pid)
  1925.             goto out;
  1926.  
  1927.         /* now create stream */
  1928.         if (ts->pids[pid] && ts->pids[pid]->type == MPEGTS_PES) {
  1929.             pes = ts->pids[pid]->u.pes_filter.opaque;
  1930.             if (!pes->st) {
  1931.                 pes->st     = avformat_new_stream(pes->stream, NULL);
  1932.                 if (!pes->st)
  1933.                     goto out;
  1934.                 pes->st->id = pes->pid;
  1935.             }
  1936.             st = pes->st;
  1937.         } else if (stream_type != 0x13) {
  1938.             if (ts->pids[pid])
  1939.                 mpegts_close_filter(ts, ts->pids[pid]); // wrongly added sdt filter probably
  1940.             pes = add_pes_stream(ts, pid, pcr_pid);
  1941.             if (pes) {
  1942.                 st = avformat_new_stream(pes->stream, NULL);
  1943.                 if (!st)
  1944.                     goto out;
  1945.                 st->id = pes->pid;
  1946.             }
  1947.         } else {
  1948.             int idx = ff_find_stream_index(ts->stream, pid);
  1949.             if (idx >= 0) {
  1950.                 st = ts->stream->streams[idx];
  1951.             } else {
  1952.                 st = avformat_new_stream(ts->stream, NULL);
  1953.                 if (!st)
  1954.                     goto out;
  1955.                 st->id = pid;
  1956.                 st->codec->codec_type = AVMEDIA_TYPE_DATA;
  1957.             }
  1958.         }
  1959.  
  1960.         if (!st)
  1961.             goto out;
  1962.  
  1963.         if (pes && !pes->stream_type)
  1964.             mpegts_set_stream_info(st, pes, stream_type, prog_reg_desc);
  1965.  
  1966.         add_pid_to_pmt(ts, h->id, pid);
  1967.  
  1968.         ff_program_add_stream_index(ts->stream, h->id, st->index);
  1969.  
  1970.         desc_list_len = get16(&p, p_end);
  1971.         if (desc_list_len < 0)
  1972.             goto out;
  1973.         desc_list_len &= 0xfff;
  1974.         desc_list_end  = p + desc_list_len;
  1975.         if (desc_list_end > p_end)
  1976.             goto out;
  1977.         for (;;) {
  1978.             if (ff_parse_mpeg2_descriptor(ts->stream, st, stream_type, &p,
  1979.                                           desc_list_end, mp4_descr,
  1980.                                           mp4_descr_count, pid, ts) < 0)
  1981.                 break;
  1982.  
  1983.             if (pes && prog_reg_desc == AV_RL32("HDMV") &&
  1984.                 stream_type == 0x83 && pes->sub_st) {
  1985.                 ff_program_add_stream_index(ts->stream, h->id,
  1986.                                             pes->sub_st->index);
  1987.                 pes->sub_st->codec->codec_tag = st->codec->codec_tag;
  1988.             }
  1989.         }
  1990.         p = desc_list_end;
  1991.     }
  1992.  
  1993.     if (!ts->pids[pcr_pid])
  1994.         mpegts_open_pcr_filter(ts, pcr_pid);
  1995.  
  1996. out:
  1997.     for (i = 0; i < mp4_descr_count; i++)
  1998.         av_free(mp4_descr[i].dec_config_descr);
  1999. }
  2000.  
  2001. static void pat_cb(MpegTSFilter *filter, const uint8_t *section, int section_len)
  2002. {
  2003.     MpegTSContext *ts = filter->u.section_filter.opaque;
  2004.     MpegTSSectionFilter *tssf = &filter->u.section_filter;
  2005.     SectionHeader h1, *h = &h1;
  2006.     const uint8_t *p, *p_end;
  2007.     int sid, pmt_pid;
  2008.     AVProgram *program;
  2009.  
  2010.     av_log(ts->stream, AV_LOG_TRACE, "PAT:\n");
  2011.     hex_dump_debug(ts->stream, section, section_len);
  2012.  
  2013.     p_end = section + section_len - 4;
  2014.     p     = section;
  2015.     if (parse_section_header(h, &p, p_end) < 0)
  2016.         return;
  2017.     if (h->tid != PAT_TID)
  2018.         return;
  2019.     if (ts->skip_changes)
  2020.         return;
  2021.  
  2022.     if (skip_identical(h, tssf))
  2023.         return;
  2024.     ts->stream->ts_id = h->id;
  2025.  
  2026.     clear_programs(ts);
  2027.     for (;;) {
  2028.         sid = get16(&p, p_end);
  2029.         if (sid < 0)
  2030.             break;
  2031.         pmt_pid = get16(&p, p_end);
  2032.         if (pmt_pid < 0)
  2033.             break;
  2034.         pmt_pid &= 0x1fff;
  2035.  
  2036.         if (pmt_pid == ts->current_pid)
  2037.             break;
  2038.  
  2039.         av_log(ts->stream, AV_LOG_TRACE, "sid=0x%x pid=0x%x\n", sid, pmt_pid);
  2040.  
  2041.         if (sid == 0x0000) {
  2042.             /* NIT info */
  2043.         } else {
  2044.             MpegTSFilter *fil = ts->pids[pmt_pid];
  2045.             program = av_new_program(ts->stream, sid);
  2046.             if (program) {
  2047.                 program->program_num = sid;
  2048.                 program->pmt_pid = pmt_pid;
  2049.             }
  2050.             if (fil)
  2051.                 if (   fil->type != MPEGTS_SECTION
  2052.                     || fil->pid != pmt_pid
  2053.                     || fil->u.section_filter.section_cb != pmt_cb)
  2054.                     mpegts_close_filter(ts, ts->pids[pmt_pid]);
  2055.  
  2056.             if (!ts->pids[pmt_pid])
  2057.                 mpegts_open_section_filter(ts, pmt_pid, pmt_cb, ts, 1);
  2058.             add_pat_entry(ts, sid);
  2059.             add_pid_to_pmt(ts, sid, 0); // add pat pid to program
  2060.             add_pid_to_pmt(ts, sid, pmt_pid);
  2061.         }
  2062.     }
  2063.  
  2064.     if (sid < 0) {
  2065.         int i,j;
  2066.         for (j=0; j<ts->stream->nb_programs; j++) {
  2067.             for (i = 0; i < ts->nb_prg; i++)
  2068.                 if (ts->prg[i].id == ts->stream->programs[j]->id)
  2069.                     break;
  2070.             if (i==ts->nb_prg && !ts->skip_clear)
  2071.                 clear_avprogram(ts, ts->stream->programs[j]->id);
  2072.         }
  2073.     }
  2074. }
  2075.  
  2076. static void sdt_cb(MpegTSFilter *filter, const uint8_t *section, int section_len)
  2077. {
  2078.     MpegTSContext *ts = filter->u.section_filter.opaque;
  2079.     MpegTSSectionFilter *tssf = &filter->u.section_filter;
  2080.     SectionHeader h1, *h = &h1;
  2081.     const uint8_t *p, *p_end, *desc_list_end, *desc_end;
  2082.     int onid, val, sid, desc_list_len, desc_tag, desc_len, service_type;
  2083.     char *name, *provider_name;
  2084.  
  2085.     av_log(ts->stream, AV_LOG_TRACE, "SDT:\n");
  2086.     hex_dump_debug(ts->stream, section, section_len);
  2087.  
  2088.     p_end = section + section_len - 4;
  2089.     p     = section;
  2090.     if (parse_section_header(h, &p, p_end) < 0)
  2091.         return;
  2092.     if (h->tid != SDT_TID)
  2093.         return;
  2094.     if (ts->skip_changes)
  2095.         return;
  2096.     if (skip_identical(h, tssf))
  2097.         return;
  2098.  
  2099.     onid = get16(&p, p_end);
  2100.     if (onid < 0)
  2101.         return;
  2102.     val = get8(&p, p_end);
  2103.     if (val < 0)
  2104.         return;
  2105.     for (;;) {
  2106.         sid = get16(&p, p_end);
  2107.         if (sid < 0)
  2108.             break;
  2109.         val = get8(&p, p_end);
  2110.         if (val < 0)
  2111.             break;
  2112.         desc_list_len = get16(&p, p_end);
  2113.         if (desc_list_len < 0)
  2114.             break;
  2115.         desc_list_len &= 0xfff;
  2116.         desc_list_end  = p + desc_list_len;
  2117.         if (desc_list_end > p_end)
  2118.             break;
  2119.         for (;;) {
  2120.             desc_tag = get8(&p, desc_list_end);
  2121.             if (desc_tag < 0)
  2122.                 break;
  2123.             desc_len = get8(&p, desc_list_end);
  2124.             desc_end = p + desc_len;
  2125.             if (desc_len < 0 || desc_end > desc_list_end)
  2126.                 break;
  2127.  
  2128.             av_log(ts->stream, AV_LOG_TRACE, "tag: 0x%02x len=%d\n",
  2129.                     desc_tag, desc_len);
  2130.  
  2131.             switch (desc_tag) {
  2132.             case 0x48:
  2133.                 service_type = get8(&p, p_end);
  2134.                 if (service_type < 0)
  2135.                     break;
  2136.                 provider_name = getstr8(&p, p_end);
  2137.                 if (!provider_name)
  2138.                     break;
  2139.                 name = getstr8(&p, p_end);
  2140.                 if (name) {
  2141.                     AVProgram *program = av_new_program(ts->stream, sid);
  2142.                     if (program) {
  2143.                         av_dict_set(&program->metadata, "service_name", name, 0);
  2144.                         av_dict_set(&program->metadata, "service_provider",
  2145.                                     provider_name, 0);
  2146.                     }
  2147.                 }
  2148.                 av_free(name);
  2149.                 av_free(provider_name);
  2150.                 break;
  2151.             default:
  2152.                 break;
  2153.             }
  2154.             p = desc_end;
  2155.         }
  2156.         p = desc_list_end;
  2157.     }
  2158. }
  2159.  
  2160. static int parse_pcr(int64_t *ppcr_high, int *ppcr_low,
  2161.                      const uint8_t *packet);
  2162.  
  2163. /* handle one TS packet */
  2164. static int handle_packet(MpegTSContext *ts, const uint8_t *packet)
  2165. {
  2166.     MpegTSFilter *tss;
  2167.     int len, pid, cc, expected_cc, cc_ok, afc, is_start, is_discontinuity,
  2168.         has_adaptation, has_payload;
  2169.     const uint8_t *p, *p_end;
  2170.     int64_t pos;
  2171.  
  2172.     pid = AV_RB16(packet + 1) & 0x1fff;
  2173.     if (pid && discard_pid(ts, pid))
  2174.         return 0;
  2175.     is_start = packet[1] & 0x40;
  2176.     tss = ts->pids[pid];
  2177.     if (ts->auto_guess && !tss && is_start) {
  2178.         add_pes_stream(ts, pid, -1);
  2179.         tss = ts->pids[pid];
  2180.     }
  2181.     if (!tss)
  2182.         return 0;
  2183.     ts->current_pid = pid;
  2184.  
  2185.     afc = (packet[3] >> 4) & 3;
  2186.     if (afc == 0) /* reserved value */
  2187.         return 0;
  2188.     has_adaptation   = afc & 2;
  2189.     has_payload      = afc & 1;
  2190.     is_discontinuity = has_adaptation &&
  2191.                        packet[4] != 0 && /* with length > 0 */
  2192.                        (packet[5] & 0x80); /* and discontinuity indicated */
  2193.  
  2194.     /* continuity check (currently not used) */
  2195.     cc = (packet[3] & 0xf);
  2196.     expected_cc = has_payload ? (tss->last_cc + 1) & 0x0f : tss->last_cc;
  2197.     cc_ok = pid == 0x1FFF || // null packet PID
  2198.             is_discontinuity ||
  2199.             tss->last_cc < 0 ||
  2200.             expected_cc == cc;
  2201.  
  2202.     tss->last_cc = cc;
  2203.     if (!cc_ok) {
  2204.         av_log(ts->stream, AV_LOG_DEBUG,
  2205.                "Continuity check failed for pid %d expected %d got %d\n",
  2206.                pid, expected_cc, cc);
  2207.         if (tss->type == MPEGTS_PES) {
  2208.             PESContext *pc = tss->u.pes_filter.opaque;
  2209.             pc->flags |= AV_PKT_FLAG_CORRUPT;
  2210.         }
  2211.     }
  2212.  
  2213.     p = packet + 4;
  2214.     if (has_adaptation) {
  2215.         int64_t pcr_h;
  2216.         int pcr_l;
  2217.         if (parse_pcr(&pcr_h, &pcr_l, packet) == 0)
  2218.             tss->last_pcr = pcr_h * 300 + pcr_l;
  2219.         /* skip adaptation field */
  2220.         p += p[0] + 1;
  2221.     }
  2222.     /* if past the end of packet, ignore */
  2223.     p_end = packet + TS_PACKET_SIZE;
  2224.     if (p >= p_end || !has_payload)
  2225.         return 0;
  2226.  
  2227.     pos = avio_tell(ts->stream->pb);
  2228.     if (pos >= 0) {
  2229.         av_assert0(pos >= TS_PACKET_SIZE);
  2230.         ts->pos47_full = pos - TS_PACKET_SIZE;
  2231.     }
  2232.  
  2233.     if (tss->type == MPEGTS_SECTION) {
  2234.         if (is_start) {
  2235.             /* pointer field present */
  2236.             len = *p++;
  2237.             if (len > p_end - p)
  2238.                 return 0;
  2239.             if (len && cc_ok) {
  2240.                 /* write remaining section bytes */
  2241.                 write_section_data(ts, tss,
  2242.                                    p, len, 0);
  2243.                 /* check whether filter has been closed */
  2244.                 if (!ts->pids[pid])
  2245.                     return 0;
  2246.             }
  2247.             p += len;
  2248.             if (p < p_end) {
  2249.                 write_section_data(ts, tss,
  2250.                                    p, p_end - p, 1);
  2251.             }
  2252.         } else {
  2253.             if (cc_ok) {
  2254.                 write_section_data(ts, tss,
  2255.                                    p, p_end - p, 0);
  2256.             }
  2257.         }
  2258.  
  2259.         // stop find_stream_info from waiting for more streams
  2260.         // when all programs have received a PMT
  2261.         if (ts->stream->ctx_flags & AVFMTCTX_NOHEADER && ts->scan_all_pmts <= 0) {
  2262.             int i;
  2263.             for (i = 0; i < ts->nb_prg; i++) {
  2264.                 if (!ts->prg[i].pmt_found)
  2265.                     break;
  2266.             }
  2267.             if (i == ts->nb_prg && ts->nb_prg > 0) {
  2268.                 int types = 0;
  2269.                 for (i = 0; i < ts->stream->nb_streams; i++) {
  2270.                     AVStream *st = ts->stream->streams[i];
  2271.                     types |= 1<<st->codec->codec_type;
  2272.                 }
  2273.                 if ((types & (1<<AVMEDIA_TYPE_AUDIO) && types & (1<<AVMEDIA_TYPE_VIDEO)) || pos > 100000) {
  2274.                     av_log(ts->stream, AV_LOG_DEBUG, "All programs have pmt, headers found\n");
  2275.                     ts->stream->ctx_flags &= ~AVFMTCTX_NOHEADER;
  2276.                 }
  2277.             }
  2278.         }
  2279.  
  2280.     } else {
  2281.         int ret;
  2282.         // Note: The position here points actually behind the current packet.
  2283.         if (tss->type == MPEGTS_PES) {
  2284.             if ((ret = tss->u.pes_filter.pes_cb(tss, p, p_end - p, is_start,
  2285.                                                 pos - ts->raw_packet_size)) < 0)
  2286.                 return ret;
  2287.         }
  2288.     }
  2289.  
  2290.     return 0;
  2291. }
  2292.  
  2293. static void reanalyze(MpegTSContext *ts) {
  2294.     AVIOContext *pb = ts->stream->pb;
  2295.     int64_t pos = avio_tell(pb);
  2296.     if (pos < 0)
  2297.         return;
  2298.     pos -= ts->pos47_full;
  2299.     if (pos == TS_PACKET_SIZE) {
  2300.         ts->size_stat[0] ++;
  2301.     } else if (pos == TS_DVHS_PACKET_SIZE) {
  2302.         ts->size_stat[1] ++;
  2303.     } else if (pos == TS_FEC_PACKET_SIZE) {
  2304.         ts->size_stat[2] ++;
  2305.     }
  2306.  
  2307.     ts->size_stat_count ++;
  2308.     if (ts->size_stat_count > SIZE_STAT_THRESHOLD) {
  2309.         int newsize = 0;
  2310.         if (ts->size_stat[0] > SIZE_STAT_THRESHOLD) {
  2311.             newsize = TS_PACKET_SIZE;
  2312.         } else if (ts->size_stat[1] > SIZE_STAT_THRESHOLD) {
  2313.             newsize = TS_DVHS_PACKET_SIZE;
  2314.         } else if (ts->size_stat[2] > SIZE_STAT_THRESHOLD) {
  2315.             newsize = TS_FEC_PACKET_SIZE;
  2316.         }
  2317.         if (newsize && newsize != ts->raw_packet_size) {
  2318.             av_log(ts->stream, AV_LOG_WARNING, "changing packet size to %d\n", newsize);
  2319.             ts->raw_packet_size = newsize;
  2320.         }
  2321.         ts->size_stat_count = 0;
  2322.         memset(ts->size_stat, 0, sizeof(ts->size_stat));
  2323.     }
  2324. }
  2325.  
  2326. /* XXX: try to find a better synchro over several packets (use
  2327.  * get_packet_size() ?) */
  2328. static int mpegts_resync(AVFormatContext *s)
  2329. {
  2330.     MpegTSContext *ts = s->priv_data;
  2331.     AVIOContext *pb = s->pb;
  2332.     int c, i;
  2333.  
  2334.     for (i = 0; i < ts->resync_size; i++) {
  2335.         c = avio_r8(pb);
  2336.         if (avio_feof(pb))
  2337.             return AVERROR_EOF;
  2338.         if (c == 0x47) {
  2339.             avio_seek(pb, -1, SEEK_CUR);
  2340.             reanalyze(s->priv_data);
  2341.             return 0;
  2342.         }
  2343.     }
  2344.     av_log(s, AV_LOG_ERROR,
  2345.            "max resync size reached, could not find sync byte\n");
  2346.     /* no sync found */
  2347.     return AVERROR_INVALIDDATA;
  2348. }
  2349.  
  2350. /* return AVERROR_something if error or EOF. Return 0 if OK. */
  2351. static int read_packet(AVFormatContext *s, uint8_t *buf, int raw_packet_size,
  2352.                        const uint8_t **data)
  2353. {
  2354.     AVIOContext *pb = s->pb;
  2355.     int len;
  2356.  
  2357.     for (;;) {
  2358.         len = ffio_read_indirect(pb, buf, TS_PACKET_SIZE, data);
  2359.         if (len != TS_PACKET_SIZE)
  2360.             return len < 0 ? len : AVERROR_EOF;
  2361.         /* check packet sync byte */
  2362.         if ((*data)[0] != 0x47) {
  2363.             /* find a new packet start */
  2364.             uint64_t pos = avio_tell(pb);
  2365.             avio_seek(pb, -FFMIN(raw_packet_size, pos), SEEK_CUR);
  2366.  
  2367.             if (mpegts_resync(s) < 0)
  2368.                 return AVERROR(EAGAIN);
  2369.             else
  2370.                 continue;
  2371.         } else {
  2372.             break;
  2373.         }
  2374.     }
  2375.     return 0;
  2376. }
  2377.  
  2378. static void finished_reading_packet(AVFormatContext *s, int raw_packet_size)
  2379. {
  2380.     AVIOContext *pb = s->pb;
  2381.     int skip = raw_packet_size - TS_PACKET_SIZE;
  2382.     if (skip > 0)
  2383.         avio_skip(pb, skip);
  2384. }
  2385.  
  2386. static int handle_packets(MpegTSContext *ts, int64_t nb_packets)
  2387. {
  2388.     AVFormatContext *s = ts->stream;
  2389.     uint8_t packet[TS_PACKET_SIZE + AV_INPUT_BUFFER_PADDING_SIZE];
  2390.     const uint8_t *data;
  2391.     int64_t packet_num;
  2392.     int ret = 0;
  2393.  
  2394.     if (avio_tell(s->pb) != ts->last_pos) {
  2395.         int i;
  2396.         av_log(ts->stream, AV_LOG_TRACE, "Skipping after seek\n");
  2397.         /* seek detected, flush pes buffer */
  2398.         for (i = 0; i < NB_PID_MAX; i++) {
  2399.             if (ts->pids[i]) {
  2400.                 if (ts->pids[i]->type == MPEGTS_PES) {
  2401.                     PESContext *pes = ts->pids[i]->u.pes_filter.opaque;
  2402.                     av_buffer_unref(&pes->buffer);
  2403.                     pes->data_index = 0;
  2404.                     pes->state = MPEGTS_SKIP; /* skip until pes header */
  2405.                 } else if (ts->pids[i]->type == MPEGTS_SECTION) {
  2406.                     ts->pids[i]->u.section_filter.last_ver = -1;
  2407.                 }
  2408.                 ts->pids[i]->last_cc = -1;
  2409.                 ts->pids[i]->last_pcr = -1;
  2410.             }
  2411.         }
  2412.     }
  2413.  
  2414.     ts->stop_parse = 0;
  2415.     packet_num = 0;
  2416.     memset(packet + TS_PACKET_SIZE, 0, AV_INPUT_BUFFER_PADDING_SIZE);
  2417.     for (;;) {
  2418.         packet_num++;
  2419.         if (nb_packets != 0 && packet_num >= nb_packets ||
  2420.             ts->stop_parse > 1) {
  2421.             ret = AVERROR(EAGAIN);
  2422.             break;
  2423.         }
  2424.         if (ts->stop_parse > 0)
  2425.             break;
  2426.  
  2427.         ret = read_packet(s, packet, ts->raw_packet_size, &data);
  2428.         if (ret != 0)
  2429.             break;
  2430.         ret = handle_packet(ts, data);
  2431.         finished_reading_packet(s, ts->raw_packet_size);
  2432.         if (ret != 0)
  2433.             break;
  2434.     }
  2435.     ts->last_pos = avio_tell(s->pb);
  2436.     return ret;
  2437. }
  2438.  
  2439. static int mpegts_probe(AVProbeData *p)
  2440. {
  2441.     const int size = p->buf_size;
  2442.     int maxscore = 0;
  2443.     int sumscore = 0;
  2444.     int i;
  2445.     int check_count = size / TS_FEC_PACKET_SIZE;
  2446. #define CHECK_COUNT 10
  2447. #define CHECK_BLOCK 100
  2448.  
  2449.     if (check_count < CHECK_COUNT)
  2450.         return 0;
  2451.  
  2452.     for (i = 0; i<check_count; i+=CHECK_BLOCK) {
  2453.         int left = FFMIN(check_count - i, CHECK_BLOCK);
  2454.         int score      = analyze(p->buf + TS_PACKET_SIZE     *i, TS_PACKET_SIZE     *left, TS_PACKET_SIZE     , NULL, 1);
  2455.         int dvhs_score = analyze(p->buf + TS_DVHS_PACKET_SIZE*i, TS_DVHS_PACKET_SIZE*left, TS_DVHS_PACKET_SIZE, NULL, 1);
  2456.         int fec_score  = analyze(p->buf + TS_FEC_PACKET_SIZE *i, TS_FEC_PACKET_SIZE *left, TS_FEC_PACKET_SIZE , NULL, 1);
  2457.         score = FFMAX3(score, dvhs_score, fec_score);
  2458.         sumscore += score;
  2459.         maxscore = FFMAX(maxscore, score);
  2460.     }
  2461.  
  2462.     sumscore = sumscore * CHECK_COUNT / check_count;
  2463.     maxscore = maxscore * CHECK_COUNT / CHECK_BLOCK;
  2464.  
  2465.     ff_dlog(0, "TS score: %d %d\n", sumscore, maxscore);
  2466.  
  2467.     if      (sumscore > 6) return AVPROBE_SCORE_MAX   + sumscore - CHECK_COUNT;
  2468.     else if (maxscore > 6) return AVPROBE_SCORE_MAX/2 + sumscore - CHECK_COUNT;
  2469.     else
  2470.         return 0;
  2471. }
  2472.  
  2473. /* return the 90kHz PCR and the extension for the 27MHz PCR. return
  2474.  * (-1) if not available */
  2475. static int parse_pcr(int64_t *ppcr_high, int *ppcr_low, const uint8_t *packet)
  2476. {
  2477.     int afc, len, flags;
  2478.     const uint8_t *p;
  2479.     unsigned int v;
  2480.  
  2481.     afc = (packet[3] >> 4) & 3;
  2482.     if (afc <= 1)
  2483.         return AVERROR_INVALIDDATA;
  2484.     p   = packet + 4;
  2485.     len = p[0];
  2486.     p++;
  2487.     if (len == 0)
  2488.         return AVERROR_INVALIDDATA;
  2489.     flags = *p++;
  2490.     len--;
  2491.     if (!(flags & 0x10))
  2492.         return AVERROR_INVALIDDATA;
  2493.     if (len < 6)
  2494.         return AVERROR_INVALIDDATA;
  2495.     v          = AV_RB32(p);
  2496.     *ppcr_high = ((int64_t) v << 1) | (p[4] >> 7);
  2497.     *ppcr_low  = ((p[4] & 1) << 8) | p[5];
  2498.     return 0;
  2499. }
  2500.  
  2501. static void seek_back(AVFormatContext *s, AVIOContext *pb, int64_t pos) {
  2502.  
  2503.     /* NOTE: We attempt to seek on non-seekable files as well, as the
  2504.      * probe buffer usually is big enough. Only warn if the seek failed
  2505.      * on files where the seek should work. */
  2506.     if (avio_seek(pb, pos, SEEK_SET) < 0)
  2507.         av_log(s, pb->seekable ? AV_LOG_ERROR : AV_LOG_INFO, "Unable to seek back to the start\n");
  2508. }
  2509.  
  2510. static int mpegts_read_header(AVFormatContext *s)
  2511. {
  2512.     MpegTSContext *ts = s->priv_data;
  2513.     AVIOContext *pb   = s->pb;
  2514.     uint8_t buf[8 * 1024] = {0};
  2515.     int len;
  2516.     int64_t pos, probesize =
  2517. #if FF_API_PROBESIZE_32
  2518.                              s->probesize ? s->probesize : s->probesize2;
  2519. #else
  2520.                              s->probesize;
  2521. #endif
  2522.  
  2523.     if (ffio_ensure_seekback(pb, probesize) < 0)
  2524.         av_log(s, AV_LOG_WARNING, "Failed to allocate buffers for seekback\n");
  2525.  
  2526.     /* read the first 8192 bytes to get packet size */
  2527.     pos = avio_tell(pb);
  2528.     len = avio_read(pb, buf, sizeof(buf));
  2529.     ts->raw_packet_size = get_packet_size(buf, len);
  2530.     if (ts->raw_packet_size <= 0) {
  2531.         av_log(s, AV_LOG_WARNING, "Could not detect TS packet size, defaulting to non-FEC/DVHS\n");
  2532.         ts->raw_packet_size = TS_PACKET_SIZE;
  2533.     }
  2534.     ts->stream     = s;
  2535.     ts->auto_guess = 0;
  2536.  
  2537.     if (s->iformat == &ff_mpegts_demuxer) {
  2538.         /* normal demux */
  2539.  
  2540.         /* first do a scan to get all the services */
  2541.         seek_back(s, pb, pos);
  2542.  
  2543.         mpegts_open_section_filter(ts, SDT_PID, sdt_cb, ts, 1);
  2544.  
  2545.         mpegts_open_section_filter(ts, PAT_PID, pat_cb, ts, 1);
  2546.  
  2547.         handle_packets(ts, probesize / ts->raw_packet_size);
  2548.         /* if could not find service, enable auto_guess */
  2549.  
  2550.         ts->auto_guess = 1;
  2551.  
  2552.         av_log(ts->stream, AV_LOG_TRACE, "tuning done\n");
  2553.  
  2554.         s->ctx_flags |= AVFMTCTX_NOHEADER;
  2555.     } else {
  2556.         AVStream *st;
  2557.         int pcr_pid, pid, nb_packets, nb_pcrs, ret, pcr_l;
  2558.         int64_t pcrs[2], pcr_h;
  2559.         int packet_count[2];
  2560.         uint8_t packet[TS_PACKET_SIZE];
  2561.         const uint8_t *data;
  2562.  
  2563.         /* only read packets */
  2564.  
  2565.         st = avformat_new_stream(s, NULL);
  2566.         if (!st)
  2567.             return AVERROR(ENOMEM);
  2568.         avpriv_set_pts_info(st, 60, 1, 27000000);
  2569.         st->codec->codec_type = AVMEDIA_TYPE_DATA;
  2570.         st->codec->codec_id   = AV_CODEC_ID_MPEG2TS;
  2571.  
  2572.         /* we iterate until we find two PCRs to estimate the bitrate */
  2573.         pcr_pid    = -1;
  2574.         nb_pcrs    = 0;
  2575.         nb_packets = 0;
  2576.         for (;;) {
  2577.             ret = read_packet(s, packet, ts->raw_packet_size, &data);
  2578.             if (ret < 0)
  2579.                 return ret;
  2580.             pid = AV_RB16(data + 1) & 0x1fff;
  2581.             if ((pcr_pid == -1 || pcr_pid == pid) &&
  2582.                 parse_pcr(&pcr_h, &pcr_l, data) == 0) {
  2583.                 finished_reading_packet(s, ts->raw_packet_size);
  2584.                 pcr_pid = pid;
  2585.                 packet_count[nb_pcrs] = nb_packets;
  2586.                 pcrs[nb_pcrs] = pcr_h * 300 + pcr_l;
  2587.                 nb_pcrs++;
  2588.                 if (nb_pcrs >= 2)
  2589.                     break;
  2590.             } else {
  2591.                 finished_reading_packet(s, ts->raw_packet_size);
  2592.             }
  2593.             nb_packets++;
  2594.         }
  2595.  
  2596.         /* NOTE1: the bitrate is computed without the FEC */
  2597.         /* NOTE2: it is only the bitrate of the start of the stream */
  2598.         ts->pcr_incr = (pcrs[1] - pcrs[0]) / (packet_count[1] - packet_count[0]);
  2599.         ts->cur_pcr  = pcrs[0] - ts->pcr_incr * packet_count[0];
  2600.         s->bit_rate  = TS_PACKET_SIZE * 8 * 27000000LL / ts->pcr_incr;
  2601.         st->codec->bit_rate = s->bit_rate;
  2602.         st->start_time      = ts->cur_pcr;
  2603.         av_log(ts->stream, AV_LOG_TRACE, "start=%0.3f pcr=%0.3f incr=%d\n",
  2604.                 st->start_time / 1000000.0, pcrs[0] / 27e6, ts->pcr_incr);
  2605.     }
  2606.  
  2607.     seek_back(s, pb, pos);
  2608.     return 0;
  2609. }
  2610.  
  2611. #define MAX_PACKET_READAHEAD ((128 * 1024) / 188)
  2612.  
  2613. static int mpegts_raw_read_packet(AVFormatContext *s, AVPacket *pkt)
  2614. {
  2615.     MpegTSContext *ts = s->priv_data;
  2616.     int ret, i;
  2617.     int64_t pcr_h, next_pcr_h, pos;
  2618.     int pcr_l, next_pcr_l;
  2619.     uint8_t pcr_buf[12];
  2620.     const uint8_t *data;
  2621.  
  2622.     if (av_new_packet(pkt, TS_PACKET_SIZE) < 0)
  2623.         return AVERROR(ENOMEM);
  2624.     ret = read_packet(s, pkt->data, ts->raw_packet_size, &data);
  2625.     pkt->pos = avio_tell(s->pb);
  2626.     if (ret < 0) {
  2627.         av_free_packet(pkt);
  2628.         return ret;
  2629.     }
  2630.     if (data != pkt->data)
  2631.         memcpy(pkt->data, data, ts->raw_packet_size);
  2632.     finished_reading_packet(s, ts->raw_packet_size);
  2633.     if (ts->mpeg2ts_compute_pcr) {
  2634.         /* compute exact PCR for each packet */
  2635.         if (parse_pcr(&pcr_h, &pcr_l, pkt->data) == 0) {
  2636.             /* we read the next PCR (XXX: optimize it by using a bigger buffer */
  2637.             pos = avio_tell(s->pb);
  2638.             for (i = 0; i < MAX_PACKET_READAHEAD; i++) {
  2639.                 avio_seek(s->pb, pos + i * ts->raw_packet_size, SEEK_SET);
  2640.                 avio_read(s->pb, pcr_buf, 12);
  2641.                 if (parse_pcr(&next_pcr_h, &next_pcr_l, pcr_buf) == 0) {
  2642.                     /* XXX: not precise enough */
  2643.                     ts->pcr_incr =
  2644.                         ((next_pcr_h - pcr_h) * 300 + (next_pcr_l - pcr_l)) /
  2645.                         (i + 1);
  2646.                     break;
  2647.                 }
  2648.             }
  2649.             avio_seek(s->pb, pos, SEEK_SET);
  2650.             /* no next PCR found: we use previous increment */
  2651.             ts->cur_pcr = pcr_h * 300 + pcr_l;
  2652.         }
  2653.         pkt->pts      = ts->cur_pcr;
  2654.         pkt->duration = ts->pcr_incr;
  2655.         ts->cur_pcr  += ts->pcr_incr;
  2656.     }
  2657.     pkt->stream_index = 0;
  2658.     return 0;
  2659. }
  2660.  
  2661. static int mpegts_read_packet(AVFormatContext *s, AVPacket *pkt)
  2662. {
  2663.     MpegTSContext *ts = s->priv_data;
  2664.     int ret, i;
  2665.  
  2666.     pkt->size = -1;
  2667.     ts->pkt = pkt;
  2668.     ret = handle_packets(ts, 0);
  2669.     if (ret < 0) {
  2670.         av_free_packet(ts->pkt);
  2671.         /* flush pes data left */
  2672.         for (i = 0; i < NB_PID_MAX; i++)
  2673.             if (ts->pids[i] && ts->pids[i]->type == MPEGTS_PES) {
  2674.                 PESContext *pes = ts->pids[i]->u.pes_filter.opaque;
  2675.                 if (pes->state == MPEGTS_PAYLOAD && pes->data_index > 0) {
  2676.                     new_pes_packet(pes, pkt);
  2677.                     pes->state = MPEGTS_SKIP;
  2678.                     ret = 0;
  2679.                     break;
  2680.                 }
  2681.             }
  2682.     }
  2683.  
  2684.     if (!ret && pkt->size < 0)
  2685.         ret = AVERROR(EINTR);
  2686.     return ret;
  2687. }
  2688.  
  2689. static void mpegts_free(MpegTSContext *ts)
  2690. {
  2691.     int i;
  2692.  
  2693.     clear_programs(ts);
  2694.  
  2695.     for (i = 0; i < NB_PID_MAX; i++)
  2696.         if (ts->pids[i])
  2697.             mpegts_close_filter(ts, ts->pids[i]);
  2698. }
  2699.  
  2700. static int mpegts_read_close(AVFormatContext *s)
  2701. {
  2702.     MpegTSContext *ts = s->priv_data;
  2703.     mpegts_free(ts);
  2704.     return 0;
  2705. }
  2706.  
  2707. static av_unused int64_t mpegts_get_pcr(AVFormatContext *s, int stream_index,
  2708.                               int64_t *ppos, int64_t pos_limit)
  2709. {
  2710.     MpegTSContext *ts = s->priv_data;
  2711.     int64_t pos, timestamp;
  2712.     uint8_t buf[TS_PACKET_SIZE];
  2713.     int pcr_l, pcr_pid =
  2714.         ((PESContext *)s->streams[stream_index]->priv_data)->pcr_pid;
  2715.     int pos47 = ts->pos47_full % ts->raw_packet_size;
  2716.     pos =
  2717.         ((*ppos + ts->raw_packet_size - 1 - pos47) / ts->raw_packet_size) *
  2718.         ts->raw_packet_size + pos47;
  2719.     while(pos < pos_limit) {
  2720.         if (avio_seek(s->pb, pos, SEEK_SET) < 0)
  2721.             return AV_NOPTS_VALUE;
  2722.         if (avio_read(s->pb, buf, TS_PACKET_SIZE) != TS_PACKET_SIZE)
  2723.             return AV_NOPTS_VALUE;
  2724.         if (buf[0] != 0x47) {
  2725.             avio_seek(s->pb, -TS_PACKET_SIZE, SEEK_CUR);
  2726.             if (mpegts_resync(s) < 0)
  2727.                 return AV_NOPTS_VALUE;
  2728.             pos = avio_tell(s->pb);
  2729.             continue;
  2730.         }
  2731.         if ((pcr_pid < 0 || (AV_RB16(buf + 1) & 0x1fff) == pcr_pid) &&
  2732.             parse_pcr(&timestamp, &pcr_l, buf) == 0) {
  2733.             *ppos = pos;
  2734.             return timestamp;
  2735.         }
  2736.         pos += ts->raw_packet_size;
  2737.     }
  2738.  
  2739.     return AV_NOPTS_VALUE;
  2740. }
  2741.  
  2742. static int64_t mpegts_get_dts(AVFormatContext *s, int stream_index,
  2743.                               int64_t *ppos, int64_t pos_limit)
  2744. {
  2745.     MpegTSContext *ts = s->priv_data;
  2746.     int64_t pos;
  2747.     int pos47 = ts->pos47_full % ts->raw_packet_size;
  2748.     pos = ((*ppos  + ts->raw_packet_size - 1 - pos47) / ts->raw_packet_size) * ts->raw_packet_size + pos47;
  2749.     ff_read_frame_flush(s);
  2750.     if (avio_seek(s->pb, pos, SEEK_SET) < 0)
  2751.         return AV_NOPTS_VALUE;
  2752.     while(pos < pos_limit) {
  2753.         int ret;
  2754.         AVPacket pkt;
  2755.         av_init_packet(&pkt);
  2756.         ret = av_read_frame(s, &pkt);
  2757.         if (ret < 0)
  2758.             return AV_NOPTS_VALUE;
  2759.         av_free_packet(&pkt);
  2760.         if (pkt.dts != AV_NOPTS_VALUE && pkt.pos >= 0) {
  2761.             ff_reduce_index(s, pkt.stream_index);
  2762.             av_add_index_entry(s->streams[pkt.stream_index], pkt.pos, pkt.dts, 0, 0, AVINDEX_KEYFRAME /* FIXME keyframe? */);
  2763.             if (pkt.stream_index == stream_index && pkt.pos >= *ppos) {
  2764.                 *ppos = pkt.pos;
  2765.                 return pkt.dts;
  2766.             }
  2767.         }
  2768.         pos = pkt.pos;
  2769.     }
  2770.  
  2771.     return AV_NOPTS_VALUE;
  2772. }
  2773.  
  2774. /**************************************************************/
  2775. /* parsing functions - called from other demuxers such as RTP */
  2776.  
  2777. MpegTSContext *avpriv_mpegts_parse_open(AVFormatContext *s)
  2778. {
  2779.     MpegTSContext *ts;
  2780.  
  2781.     ts = av_mallocz(sizeof(MpegTSContext));
  2782.     if (!ts)
  2783.         return NULL;
  2784.     /* no stream case, currently used by RTP */
  2785.     ts->raw_packet_size = TS_PACKET_SIZE;
  2786.     ts->stream = s;
  2787.     ts->auto_guess = 1;
  2788.     mpegts_open_section_filter(ts, SDT_PID, sdt_cb, ts, 1);
  2789.     mpegts_open_section_filter(ts, PAT_PID, pat_cb, ts, 1);
  2790.  
  2791.     return ts;
  2792. }
  2793.  
  2794. /* return the consumed length if a packet was output, or -1 if no
  2795.  * packet is output */
  2796. int avpriv_mpegts_parse_packet(MpegTSContext *ts, AVPacket *pkt,
  2797.                                const uint8_t *buf, int len)
  2798. {
  2799.     int len1;
  2800.  
  2801.     len1 = len;
  2802.     ts->pkt = pkt;
  2803.     for (;;) {
  2804.         ts->stop_parse = 0;
  2805.         if (len < TS_PACKET_SIZE)
  2806.             return AVERROR_INVALIDDATA;
  2807.         if (buf[0] != 0x47) {
  2808.             buf++;
  2809.             len--;
  2810.         } else {
  2811.             handle_packet(ts, buf);
  2812.             buf += TS_PACKET_SIZE;
  2813.             len -= TS_PACKET_SIZE;
  2814.             if (ts->stop_parse == 1)
  2815.                 break;
  2816.         }
  2817.     }
  2818.     return len1 - len;
  2819. }
  2820.  
  2821. void avpriv_mpegts_parse_close(MpegTSContext *ts)
  2822. {
  2823.     mpegts_free(ts);
  2824.     av_free(ts);
  2825. }
  2826.  
  2827. AVInputFormat ff_mpegts_demuxer = {
  2828.     .name           = "mpegts",
  2829.     .long_name      = NULL_IF_CONFIG_SMALL("MPEG-TS (MPEG-2 Transport Stream)"),
  2830.     .priv_data_size = sizeof(MpegTSContext),
  2831.     .read_probe     = mpegts_probe,
  2832.     .read_header    = mpegts_read_header,
  2833.     .read_packet    = mpegts_read_packet,
  2834.     .read_close     = mpegts_read_close,
  2835.     .read_timestamp = mpegts_get_dts,
  2836.     .flags          = AVFMT_SHOW_IDS | AVFMT_TS_DISCONT,
  2837.     .priv_class     = &mpegts_class,
  2838. };
  2839.  
  2840. AVInputFormat ff_mpegtsraw_demuxer = {
  2841.     .name           = "mpegtsraw",
  2842.     .long_name      = NULL_IF_CONFIG_SMALL("raw MPEG-TS (MPEG-2 Transport Stream)"),
  2843.     .priv_data_size = sizeof(MpegTSContext),
  2844.     .read_header    = mpegts_read_header,
  2845.     .read_packet    = mpegts_raw_read_packet,
  2846.     .read_close     = mpegts_read_close,
  2847.     .read_timestamp = mpegts_get_dts,
  2848.     .flags          = AVFMT_SHOW_IDS | AVFMT_TS_DISCONT,
  2849.     .priv_class     = &mpegtsraw_class,
  2850. };
  2851.