Line | Branch | Exec | Source |
---|---|---|---|
1 | /* | ||
2 | * MPEG-2 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 "config_components.h" | ||
23 | |||
24 | #include "libavutil/buffer.h" | ||
25 | #include "libavutil/crc.h" | ||
26 | #include "libavutil/internal.h" | ||
27 | #include "libavutil/intreadwrite.h" | ||
28 | #include "libavutil/log.h" | ||
29 | #include "libavutil/dict.h" | ||
30 | #include "libavutil/mem.h" | ||
31 | #include "libavutil/opt.h" | ||
32 | #include "libavutil/avassert.h" | ||
33 | #include "libavutil/dovi_meta.h" | ||
34 | #include "libavcodec/bytestream.h" | ||
35 | #include "libavcodec/defs.h" | ||
36 | #include "libavcodec/get_bits.h" | ||
37 | #include "libavcodec/opus.h" | ||
38 | #include "avformat.h" | ||
39 | #include "mpegts.h" | ||
40 | #include "internal.h" | ||
41 | #include "avio_internal.h" | ||
42 | #include "demux.h" | ||
43 | #include "mpeg.h" | ||
44 | #include "isom.h" | ||
45 | #if CONFIG_ICONV | ||
46 | #include <iconv.h> | ||
47 | #endif | ||
48 | |||
49 | /* maximum size in which we look for synchronization if | ||
50 | * synchronization is lost */ | ||
51 | #define MAX_RESYNC_SIZE 65536 | ||
52 | |||
53 | #define MAX_MP4_DESCR_COUNT 16 | ||
54 | |||
55 | #define MOD_UNLIKELY(modulus, dividend, divisor, prev_dividend) \ | ||
56 | do { \ | ||
57 | if ((prev_dividend) == 0 || (dividend) - (prev_dividend) != (divisor)) \ | ||
58 | (modulus) = (dividend) % (divisor); \ | ||
59 | (prev_dividend) = (dividend); \ | ||
60 | } while (0) | ||
61 | |||
62 | #define PROBE_PACKET_MAX_BUF 8192 | ||
63 | #define PROBE_PACKET_MARGIN 5 | ||
64 | |||
65 | enum MpegTSFilterType { | ||
66 | MPEGTS_PES, | ||
67 | MPEGTS_SECTION, | ||
68 | MPEGTS_PCR, | ||
69 | }; | ||
70 | |||
71 | typedef struct MpegTSFilter MpegTSFilter; | ||
72 | |||
73 | typedef int PESCallback (MpegTSFilter *f, const uint8_t *buf, int len, | ||
74 | int is_start, int64_t pos); | ||
75 | |||
76 | typedef struct MpegTSPESFilter { | ||
77 | PESCallback *pes_cb; | ||
78 | void *opaque; | ||
79 | } MpegTSPESFilter; | ||
80 | |||
81 | typedef void SectionCallback (MpegTSFilter *f, const uint8_t *buf, int len); | ||
82 | |||
83 | typedef void SetServiceCallback (void *opaque, int ret); | ||
84 | |||
85 | typedef struct MpegTSSectionFilter { | ||
86 | int section_index; | ||
87 | int section_h_size; | ||
88 | int last_ver; | ||
89 | unsigned crc; | ||
90 | unsigned last_crc; | ||
91 | uint8_t *section_buf; | ||
92 | unsigned int check_crc : 1; | ||
93 | unsigned int end_of_section_reached : 1; | ||
94 | SectionCallback *section_cb; | ||
95 | void *opaque; | ||
96 | } MpegTSSectionFilter; | ||
97 | |||
98 | struct MpegTSFilter { | ||
99 | int pid; | ||
100 | int es_id; | ||
101 | int last_cc; /* last cc code (-1 if first packet) */ | ||
102 | int64_t last_pcr; | ||
103 | int discard; | ||
104 | enum MpegTSFilterType type; | ||
105 | union { | ||
106 | MpegTSPESFilter pes_filter; | ||
107 | MpegTSSectionFilter section_filter; | ||
108 | } u; | ||
109 | }; | ||
110 | |||
111 | struct Stream { | ||
112 | int idx; | ||
113 | int stream_identifier; | ||
114 | }; | ||
115 | |||
116 | #define MAX_STREAMS_PER_PROGRAM 128 | ||
117 | #define MAX_PIDS_PER_PROGRAM (MAX_STREAMS_PER_PROGRAM + 2) | ||
118 | struct Program { | ||
119 | unsigned int id; // program id/service id | ||
120 | unsigned int nb_pids; | ||
121 | unsigned int pids[MAX_PIDS_PER_PROGRAM]; | ||
122 | unsigned int nb_streams; | ||
123 | struct Stream streams[MAX_STREAMS_PER_PROGRAM]; | ||
124 | |||
125 | /** have we found pmt for this program */ | ||
126 | int pmt_found; | ||
127 | }; | ||
128 | |||
129 | struct MpegTSContext { | ||
130 | const AVClass *class; | ||
131 | /* user data */ | ||
132 | AVFormatContext *stream; | ||
133 | /** raw packet size, including FEC if present */ | ||
134 | int raw_packet_size; | ||
135 | |||
136 | int64_t pos47_full; | ||
137 | |||
138 | /** if true, all pids are analyzed to find streams */ | ||
139 | int auto_guess; | ||
140 | |||
141 | /** compute exact PCR for each transport stream packet */ | ||
142 | int mpeg2ts_compute_pcr; | ||
143 | |||
144 | /** fix dvb teletext pts */ | ||
145 | int fix_teletext_pts; | ||
146 | |||
147 | int64_t cur_pcr; /**< used to estimate the exact PCR */ | ||
148 | int64_t pcr_incr; /**< used to estimate the exact PCR */ | ||
149 | |||
150 | /* data needed to handle file based ts */ | ||
151 | /** stop parsing loop */ | ||
152 | int stop_parse; | ||
153 | /** packet containing Audio/Video data */ | ||
154 | AVPacket *pkt; | ||
155 | /** to detect seek */ | ||
156 | int64_t last_pos; | ||
157 | |||
158 | int skip_changes; | ||
159 | int skip_clear; | ||
160 | int skip_unknown_pmt; | ||
161 | |||
162 | int scan_all_pmts; | ||
163 | |||
164 | int resync_size; | ||
165 | int merge_pmt_versions; | ||
166 | int max_packet_size; | ||
167 | |||
168 | int id; | ||
169 | |||
170 | /******************************************/ | ||
171 | /* private mpegts data */ | ||
172 | /* scan context */ | ||
173 | /** structure to keep track of Program->pids mapping */ | ||
174 | unsigned int nb_prg; | ||
175 | struct Program *prg; | ||
176 | |||
177 | int8_t crc_validity[NB_PID_MAX]; | ||
178 | /** filters for various streams specified by PMT + for the PAT and PMT */ | ||
179 | MpegTSFilter *pids[NB_PID_MAX]; | ||
180 | int current_pid; | ||
181 | |||
182 | AVStream *epg_stream; | ||
183 | AVBufferPool* pools[32]; | ||
184 | }; | ||
185 | |||
186 | #define MPEGTS_OPTIONS \ | ||
187 | { "resync_size", "set size limit for looking up a new synchronization", \ | ||
188 | offsetof(MpegTSContext, resync_size), AV_OPT_TYPE_INT, \ | ||
189 | { .i64 = MAX_RESYNC_SIZE}, 0, INT_MAX, AV_OPT_FLAG_DECODING_PARAM }, \ | ||
190 | { "ts_id", "transport stream id", \ | ||
191 | offsetof(MpegTSContext, id), AV_OPT_TYPE_INT, \ | ||
192 | { .i64 = 0 }, 0, INT_MAX, AV_OPT_FLAG_EXPORT | AV_OPT_FLAG_READONLY }, \ | ||
193 | { "ts_packetsize", "output option carrying the raw packet size", \ | ||
194 | offsetof(MpegTSContext, raw_packet_size), AV_OPT_TYPE_INT, \ | ||
195 | { .i64 = 0 }, 0, INT_MAX, AV_OPT_FLAG_EXPORT | AV_OPT_FLAG_READONLY } | ||
196 | |||
197 | static const AVOption options[] = { | ||
198 | MPEGTS_OPTIONS, | ||
199 | {"fix_teletext_pts", "try to fix pts values of dvb teletext streams", offsetof(MpegTSContext, fix_teletext_pts), AV_OPT_TYPE_BOOL, | ||
200 | {.i64 = 1}, 0, 1, AV_OPT_FLAG_DECODING_PARAM }, | ||
201 | {"scan_all_pmts", "scan and combine all PMTs", offsetof(MpegTSContext, scan_all_pmts), AV_OPT_TYPE_BOOL, | ||
202 | {.i64 = -1}, -1, 1, AV_OPT_FLAG_DECODING_PARAM }, | ||
203 | {"skip_unknown_pmt", "skip PMTs for programs not advertised in the PAT", offsetof(MpegTSContext, skip_unknown_pmt), AV_OPT_TYPE_BOOL, | ||
204 | {.i64 = 0}, 0, 1, AV_OPT_FLAG_DECODING_PARAM }, | ||
205 | {"merge_pmt_versions", "re-use streams when PMT's version/pids change", offsetof(MpegTSContext, merge_pmt_versions), AV_OPT_TYPE_BOOL, | ||
206 | {.i64 = 0}, 0, 1, AV_OPT_FLAG_DECODING_PARAM }, | ||
207 | {"skip_changes", "skip changing / adding streams / programs", offsetof(MpegTSContext, skip_changes), AV_OPT_TYPE_BOOL, | ||
208 | {.i64 = 0}, 0, 1, 0 }, | ||
209 | {"skip_clear", "skip clearing programs", offsetof(MpegTSContext, skip_clear), AV_OPT_TYPE_BOOL, | ||
210 | {.i64 = 0}, 0, 1, 0 }, | ||
211 | {"max_packet_size", "maximum size of emitted packet", offsetof(MpegTSContext, max_packet_size), AV_OPT_TYPE_INT, | ||
212 | {.i64 = 204800}, 1, INT_MAX/2, AV_OPT_FLAG_DECODING_PARAM }, | ||
213 | { NULL }, | ||
214 | }; | ||
215 | |||
216 | static const AVClass mpegts_class = { | ||
217 | .class_name = "mpegts demuxer", | ||
218 | .item_name = av_default_item_name, | ||
219 | .option = options, | ||
220 | .version = LIBAVUTIL_VERSION_INT, | ||
221 | }; | ||
222 | |||
223 | static const AVOption raw_options[] = { | ||
224 | MPEGTS_OPTIONS, | ||
225 | { "compute_pcr", "compute exact PCR for each transport stream packet", | ||
226 | offsetof(MpegTSContext, mpeg2ts_compute_pcr), AV_OPT_TYPE_BOOL, | ||
227 | { .i64 = 0 }, 0, 1, AV_OPT_FLAG_DECODING_PARAM }, | ||
228 | { NULL }, | ||
229 | }; | ||
230 | |||
231 | static const AVClass mpegtsraw_class = { | ||
232 | .class_name = "mpegtsraw demuxer", | ||
233 | .item_name = av_default_item_name, | ||
234 | .option = raw_options, | ||
235 | .version = LIBAVUTIL_VERSION_INT, | ||
236 | }; | ||
237 | |||
238 | /* TS stream handling */ | ||
239 | |||
240 | enum MpegTSState { | ||
241 | MPEGTS_HEADER = 0, | ||
242 | MPEGTS_PESHEADER, | ||
243 | MPEGTS_PESHEADER_FILL, | ||
244 | MPEGTS_PAYLOAD, | ||
245 | MPEGTS_SKIP, | ||
246 | }; | ||
247 | |||
248 | /* enough for PES header + length */ | ||
249 | #define PES_START_SIZE 6 | ||
250 | #define PES_HEADER_SIZE 9 | ||
251 | #define MAX_PES_HEADER_SIZE (9 + 255) | ||
252 | |||
253 | typedef struct PESContext { | ||
254 | int pid; | ||
255 | int pcr_pid; /**< if -1 then all packets containing PCR are considered */ | ||
256 | int stream_type; | ||
257 | MpegTSContext *ts; | ||
258 | AVFormatContext *stream; | ||
259 | AVStream *st; | ||
260 | AVStream *sub_st; /**< stream for the embedded AC3 stream in HDMV TrueHD */ | ||
261 | enum MpegTSState state; | ||
262 | /* used to get the format */ | ||
263 | int data_index; | ||
264 | int flags; /**< copied to the AVPacket flags */ | ||
265 | int PES_packet_length; | ||
266 | int pes_header_size; | ||
267 | int extended_stream_id; | ||
268 | uint8_t stream_id; | ||
269 | int64_t pts, dts; | ||
270 | int64_t ts_packet_pos; /**< position of first TS packet of this PES packet */ | ||
271 | uint8_t header[MAX_PES_HEADER_SIZE]; | ||
272 | AVBufferRef *buffer; | ||
273 | SLConfigDescr sl; | ||
274 | int merged_st; | ||
275 | } PESContext; | ||
276 | |||
277 | extern const FFInputFormat ff_mpegts_demuxer; | ||
278 | |||
279 | 473 | static struct Program * get_program(MpegTSContext *ts, unsigned int programid) | |
280 | { | ||
281 | int i; | ||
282 |
2/2✓ Branch 0 taken 419 times.
✓ Branch 1 taken 54 times.
|
473 | for (i = 0; i < ts->nb_prg; i++) { |
283 |
1/2✓ Branch 0 taken 419 times.
✗ Branch 1 not taken.
|
419 | if (ts->prg[i].id == programid) { |
284 | 419 | return &ts->prg[i]; | |
285 | } | ||
286 | } | ||
287 | 54 | return NULL; | |
288 | } | ||
289 | |||
290 | 169 | static void clear_avprogram(MpegTSContext *ts, unsigned int programid) | |
291 | { | ||
292 | 169 | AVProgram *prg = NULL; | |
293 | int i; | ||
294 | |||
295 |
1/2✓ Branch 0 taken 169 times.
✗ Branch 1 not taken.
|
169 | for (i = 0; i < ts->stream->nb_programs; i++) |
296 |
1/2✓ Branch 0 taken 169 times.
✗ Branch 1 not taken.
|
169 | if (ts->stream->programs[i]->id == programid) { |
297 | 169 | prg = ts->stream->programs[i]; | |
298 | 169 | break; | |
299 | } | ||
300 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 169 times.
|
169 | if (!prg) |
301 | ✗ | return; | |
302 | 169 | prg->nb_stream_indexes = 0; | |
303 | } | ||
304 | |||
305 | 317 | static void clear_program(struct Program *p) | |
306 | { | ||
307 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 317 times.
|
317 | if (!p) |
308 | ✗ | return; | |
309 | 317 | p->nb_pids = 0; | |
310 | 317 | p->nb_streams = 0; | |
311 | 317 | p->pmt_found = 0; | |
312 | } | ||
313 | |||
314 | 54 | static void clear_programs(MpegTSContext *ts) | |
315 | { | ||
316 | 54 | av_freep(&ts->prg); | |
317 | 54 | ts->nb_prg = 0; | |
318 | 54 | } | |
319 | |||
320 | 210 | static struct Program * add_program(MpegTSContext *ts, unsigned int programid) | |
321 | { | ||
322 | 210 | struct Program *p = get_program(ts, programid); | |
323 |
2/2✓ Branch 0 taken 156 times.
✓ Branch 1 taken 54 times.
|
210 | if (p) |
324 | 156 | return p; | |
325 |
1/2✗ Branch 1 not taken.
✓ Branch 2 taken 54 times.
|
54 | if (av_reallocp_array(&ts->prg, ts->nb_prg + 1, sizeof(*ts->prg)) < 0) { |
326 | ✗ | ts->nb_prg = 0; | |
327 | ✗ | return NULL; | |
328 | } | ||
329 | 54 | p = &ts->prg[ts->nb_prg]; | |
330 | 54 | p->id = programid; | |
331 | 54 | clear_program(p); | |
332 | 54 | ts->nb_prg++; | |
333 | 54 | return p; | |
334 | } | ||
335 | |||
336 | 1255 | static void add_pid_to_program(struct Program *p, unsigned int pid) | |
337 | { | ||
338 | int i; | ||
339 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 1255 times.
|
1255 | if (!p) |
340 | ✗ | return; | |
341 | |||
342 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 1255 times.
|
1255 | if (p->nb_pids >= MAX_PIDS_PER_PROGRAM) |
343 | ✗ | return; | |
344 | |||
345 |
2/2✓ Branch 0 taken 1621 times.
✓ Branch 1 taken 830 times.
|
2451 | for (i = 0; i < p->nb_pids; i++) |
346 |
2/2✓ Branch 0 taken 425 times.
✓ Branch 1 taken 1196 times.
|
1621 | if (p->pids[i] == pid) |
347 | 425 | return; | |
348 | |||
349 | 830 | p->pids[p->nb_pids++] = pid; | |
350 | } | ||
351 | |||
352 | 263 | static void update_av_program_info(AVFormatContext *s, unsigned int programid, | |
353 | unsigned int pid, int version) | ||
354 | { | ||
355 | int i; | ||
356 |
1/2✓ Branch 0 taken 263 times.
✗ Branch 1 not taken.
|
263 | for (i = 0; i < s->nb_programs; i++) { |
357 | 263 | AVProgram *program = s->programs[i]; | |
358 |
1/2✓ Branch 0 taken 263 times.
✗ Branch 1 not taken.
|
263 | if (program->id == programid) { |
359 | 263 | int old_pcr_pid = program->pcr_pid, | |
360 | 263 | old_version = program->pmt_version; | |
361 | 263 | program->pcr_pid = pid; | |
362 | 263 | program->pmt_version = version; | |
363 | |||
364 |
4/4✓ Branch 0 taken 209 times.
✓ Branch 1 taken 54 times.
✓ Branch 2 taken 13 times.
✓ Branch 3 taken 196 times.
|
263 | if (old_version != -1 && old_version != version) { |
365 | 13 | av_log(s, AV_LOG_VERBOSE, | |
366 | "detected PMT change (program=%d, version=%d/%d, pcr_pid=0x%x/0x%x)\n", | ||
367 | programid, old_version, version, old_pcr_pid, pid); | ||
368 | } | ||
369 | 263 | break; | |
370 | } | ||
371 | } | ||
372 | 263 | } | |
373 | |||
374 | /** | ||
375 | * @brief discard_pid() decides if the pid is to be discarded according | ||
376 | * to caller's programs selection | ||
377 | * @param ts : - TS context | ||
378 | * @param pid : - pid | ||
379 | * @return 1 if the pid is only comprised in programs that have .discard=AVDISCARD_ALL | ||
380 | * 0 otherwise | ||
381 | */ | ||
382 | 35875 | static int discard_pid(MpegTSContext *ts, unsigned int pid) | |
383 | { | ||
384 | int i, j, k; | ||
385 | 35875 | int used = 0, discarded = 0; | |
386 | struct Program *p; | ||
387 | |||
388 |
2/2✓ Branch 0 taken 2975 times.
✓ Branch 1 taken 32900 times.
|
35875 | if (pid == PAT_PID) |
389 | 2975 | return 0; | |
390 | |||
391 | /* If none of the programs have .discard=AVDISCARD_ALL then there's | ||
392 | * no way we have to discard this packet */ | ||
393 |
2/2✓ Branch 0 taken 32873 times.
✓ Branch 1 taken 32900 times.
|
65773 | for (k = 0; k < ts->stream->nb_programs; k++) |
394 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 32873 times.
|
32873 | if (ts->stream->programs[k]->discard == AVDISCARD_ALL) |
395 | ✗ | break; | |
396 |
1/2✓ Branch 0 taken 32900 times.
✗ Branch 1 not taken.
|
32900 | if (k == ts->stream->nb_programs) |
397 | 32900 | return 0; | |
398 | |||
399 | ✗ | for (i = 0; i < ts->nb_prg; i++) { | |
400 | ✗ | p = &ts->prg[i]; | |
401 | ✗ | for (j = 0; j < p->nb_pids; j++) { | |
402 | ✗ | if (p->pids[j] != pid) | |
403 | ✗ | continue; | |
404 | // is program with id p->id set to be discarded? | ||
405 | ✗ | for (k = 0; k < ts->stream->nb_programs; k++) { | |
406 | ✗ | if (ts->stream->programs[k]->id == p->id) { | |
407 | ✗ | if (ts->stream->programs[k]->discard == AVDISCARD_ALL) | |
408 | ✗ | discarded++; | |
409 | else | ||
410 | ✗ | used++; | |
411 | } | ||
412 | } | ||
413 | } | ||
414 | } | ||
415 | |||
416 | ✗ | return !used && discarded; | |
417 | } | ||
418 | |||
419 | /** | ||
420 | * Assemble PES packets out of TS packets, and then call the "section_cb" | ||
421 | * function when they are complete. | ||
422 | */ | ||
423 | 6406 | static void write_section_data(MpegTSContext *ts, MpegTSFilter *tss1, | |
424 | const uint8_t *buf, int buf_size, int is_start) | ||
425 | { | ||
426 | 6406 | MpegTSSectionFilter *tss = &tss1->u.section_filter; | |
427 | 6406 | uint8_t *cur_section_buf = NULL; | |
428 | int len, offset; | ||
429 | |||
430 |
2/2✓ Branch 0 taken 6371 times.
✓ Branch 1 taken 35 times.
|
6406 | if (is_start) { |
431 | 6371 | memcpy(tss->section_buf, buf, buf_size); | |
432 | 6371 | tss->section_index = buf_size; | |
433 | 6371 | tss->section_h_size = -1; | |
434 | 6371 | tss->end_of_section_reached = 0; | |
435 | } else { | ||
436 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 35 times.
|
35 | if (tss->end_of_section_reached) |
437 | ✗ | return; | |
438 | 35 | len = MAX_SECTION_SIZE - tss->section_index; | |
439 |
1/2✓ Branch 0 taken 35 times.
✗ Branch 1 not taken.
|
35 | if (buf_size < len) |
440 | 35 | len = buf_size; | |
441 | 35 | memcpy(tss->section_buf + tss->section_index, buf, len); | |
442 | 35 | tss->section_index += len; | |
443 | } | ||
444 | |||
445 | 6406 | offset = 0; | |
446 | 6406 | cur_section_buf = tss->section_buf; | |
447 |
3/4✓ Branch 0 taken 12777 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 6614 times.
✓ Branch 3 taken 6163 times.
|
12777 | while (cur_section_buf - tss->section_buf < MAX_SECTION_SIZE && cur_section_buf[0] != 0xff) { |
448 | /* compute section length if possible */ | ||
449 |
3/4✓ Branch 0 taken 6614 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 6406 times.
✓ Branch 3 taken 208 times.
|
6614 | if (tss->section_h_size == -1 && tss->section_index - offset >= 3) { |
450 | 6406 | len = (AV_RB16(cur_section_buf + 1) & 0xfff) + 3; | |
451 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 6406 times.
|
6406 | if (len > MAX_SECTION_SIZE) |
452 | ✗ | return; | |
453 | 6406 | tss->section_h_size = len; | |
454 | } | ||
455 | |||
456 |
2/2✓ Branch 0 taken 6406 times.
✓ Branch 1 taken 208 times.
|
6614 | if (tss->section_h_size != -1 && |
457 |
2/2✓ Branch 0 taken 6371 times.
✓ Branch 1 taken 35 times.
|
6406 | tss->section_index >= offset + tss->section_h_size) { |
458 | 6371 | int crc_valid = 1; | |
459 | 6371 | tss->end_of_section_reached = 1; | |
460 | |||
461 |
1/2✓ Branch 0 taken 6371 times.
✗ Branch 1 not taken.
|
6371 | if (tss->check_crc) { |
462 | 6371 | crc_valid = !av_crc(av_crc_get_table(AV_CRC_32_IEEE), -1, cur_section_buf, tss->section_h_size); | |
463 |
1/2✓ Branch 0 taken 6371 times.
✗ Branch 1 not taken.
|
6371 | if (tss->section_h_size >= 4) |
464 | 6371 | tss->crc = AV_RB32(cur_section_buf + tss->section_h_size - 4); | |
465 | |||
466 |
1/2✓ Branch 0 taken 6371 times.
✗ Branch 1 not taken.
|
6371 | if (crc_valid) { |
467 | 6371 | ts->crc_validity[ tss1->pid ] = 100; | |
468 | ✗ | }else if (ts->crc_validity[ tss1->pid ] > -10) { | |
469 | ✗ | ts->crc_validity[ tss1->pid ]--; | |
470 | }else | ||
471 | ✗ | crc_valid = 2; | |
472 | } | ||
473 |
1/2✓ Branch 0 taken 6371 times.
✗ Branch 1 not taken.
|
6371 | if (crc_valid) { |
474 | 6371 | tss->section_cb(tss1, cur_section_buf, tss->section_h_size); | |
475 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 6371 times.
|
6371 | if (crc_valid != 1) |
476 | ✗ | tss->last_ver = -1; | |
477 | } | ||
478 | |||
479 | 6371 | cur_section_buf += tss->section_h_size; | |
480 | 6371 | offset += tss->section_h_size; | |
481 | 6371 | tss->section_h_size = -1; | |
482 | } else { | ||
483 | 243 | tss->section_h_size = -1; | |
484 | 243 | tss->end_of_section_reached = 0; | |
485 | 243 | break; | |
486 | } | ||
487 | } | ||
488 | } | ||
489 | |||
490 | 339 | static MpegTSFilter *mpegts_open_filter(MpegTSContext *ts, unsigned int pid, | |
491 | enum MpegTSFilterType type) | ||
492 | { | ||
493 | MpegTSFilter *filter; | ||
494 | |||
495 | 339 | av_log(ts->stream, AV_LOG_TRACE, "Filter: pid=0x%x type=%d\n", pid, type); | |
496 | |||
497 |
2/4✓ Branch 0 taken 339 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 339 times.
|
339 | if (pid >= NB_PID_MAX || ts->pids[pid]) |
498 | ✗ | return NULL; | |
499 | 339 | filter = av_mallocz(sizeof(MpegTSFilter)); | |
500 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 339 times.
|
339 | if (!filter) |
501 | ✗ | return NULL; | |
502 | 339 | ts->pids[pid] = filter; | |
503 | |||
504 | 339 | filter->type = type; | |
505 | 339 | filter->pid = pid; | |
506 | 339 | filter->es_id = -1; | |
507 | 339 | filter->last_cc = -1; | |
508 | 339 | filter->last_pcr= -1; | |
509 | |||
510 | 339 | return filter; | |
511 | } | ||
512 | |||
513 | 221 | static MpegTSFilter *mpegts_open_section_filter(MpegTSContext *ts, | |
514 | unsigned int pid, | ||
515 | SectionCallback *section_cb, | ||
516 | void *opaque, | ||
517 | int check_crc) | ||
518 | { | ||
519 | MpegTSFilter *filter; | ||
520 | MpegTSSectionFilter *sec; | ||
521 | 221 | uint8_t *section_buf = av_mallocz(MAX_SECTION_SIZE); | |
522 | |||
523 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 221 times.
|
221 | if (!section_buf) |
524 | ✗ | return NULL; | |
525 | |||
526 |
1/2✗ Branch 1 not taken.
✓ Branch 2 taken 221 times.
|
221 | if (!(filter = mpegts_open_filter(ts, pid, MPEGTS_SECTION))) { |
527 | ✗ | av_free(section_buf); | |
528 | ✗ | return NULL; | |
529 | } | ||
530 | 221 | sec = &filter->u.section_filter; | |
531 | 221 | sec->section_cb = section_cb; | |
532 | 221 | sec->opaque = opaque; | |
533 | 221 | sec->section_buf = section_buf; | |
534 | 221 | sec->check_crc = check_crc; | |
535 | 221 | sec->last_ver = -1; | |
536 | |||
537 | 221 | return filter; | |
538 | } | ||
539 | |||
540 | 118 | static MpegTSFilter *mpegts_open_pes_filter(MpegTSContext *ts, unsigned int pid, | |
541 | PESCallback *pes_cb, | ||
542 | void *opaque) | ||
543 | { | ||
544 | MpegTSFilter *filter; | ||
545 | MpegTSPESFilter *pes; | ||
546 | |||
547 |
1/2✗ Branch 1 not taken.
✓ Branch 2 taken 118 times.
|
118 | if (!(filter = mpegts_open_filter(ts, pid, MPEGTS_PES))) |
548 | ✗ | return NULL; | |
549 | |||
550 | 118 | pes = &filter->u.pes_filter; | |
551 | 118 | pes->pes_cb = pes_cb; | |
552 | 118 | pes->opaque = opaque; | |
553 | 118 | return filter; | |
554 | } | ||
555 | |||
556 | ✗ | static MpegTSFilter *mpegts_open_pcr_filter(MpegTSContext *ts, unsigned int pid) | |
557 | { | ||
558 | ✗ | return mpegts_open_filter(ts, pid, MPEGTS_PCR); | |
559 | } | ||
560 | |||
561 | 339 | static void mpegts_close_filter(MpegTSContext *ts, MpegTSFilter *filter) | |
562 | { | ||
563 | int pid; | ||
564 | |||
565 | 339 | pid = filter->pid; | |
566 |
2/2✓ Branch 0 taken 221 times.
✓ Branch 1 taken 118 times.
|
339 | if (filter->type == MPEGTS_SECTION) |
567 | 221 | av_freep(&filter->u.section_filter.section_buf); | |
568 |
1/2✓ Branch 0 taken 118 times.
✗ Branch 1 not taken.
|
118 | else if (filter->type == MPEGTS_PES) { |
569 | 118 | PESContext *pes = filter->u.pes_filter.opaque; | |
570 | 118 | av_buffer_unref(&pes->buffer); | |
571 | /* referenced private data will be freed later in | ||
572 | * avformat_close_input (pes->st->priv_data == pes) */ | ||
573 |
4/4✓ Branch 0 taken 101 times.
✓ Branch 1 taken 17 times.
✓ Branch 2 taken 4 times.
✓ Branch 3 taken 97 times.
|
118 | if (!pes->st || pes->merged_st) { |
574 | 21 | av_freep(&filter->u.pes_filter.opaque); | |
575 | } | ||
576 | } | ||
577 | |||
578 | 339 | av_free(filter); | |
579 | 339 | ts->pids[pid] = NULL; | |
580 | 339 | } | |
581 | |||
582 | 69618 | static int analyze(const uint8_t *buf, int size, int packet_size, | |
583 | int probe) | ||
584 | { | ||
585 | int stat[TS_MAX_PACKET_SIZE]; | ||
586 | 69618 | int stat_all = 0; | |
587 | int i; | ||
588 | 69618 | int best_score = 0; | |
589 | |||
590 | 69618 | memset(stat, 0, packet_size * sizeof(*stat)); | |
591 | |||
592 |
2/2✓ Branch 0 taken 1055677074 times.
✓ Branch 1 taken 69618 times.
|
1055746692 | for (i = 0; i < size - 3; i++) { |
593 |
2/2✓ Branch 0 taken 1866987 times.
✓ Branch 1 taken 1053810087 times.
|
1055677074 | if (buf[i] == 0x47) { |
594 | 1866987 | int pid = AV_RB16(buf+1) & 0x1FFF; | |
595 | 1866987 | int asc = buf[i + 3] & 0x30; | |
596 |
6/6✓ Branch 0 taken 1845417 times.
✓ Branch 1 taken 21570 times.
✓ Branch 2 taken 1843575 times.
✓ Branch 3 taken 1842 times.
✓ Branch 4 taken 1508258 times.
✓ Branch 5 taken 335317 times.
|
1866987 | if (!probe || pid == 0x1FFF || asc) { |
597 | 1531670 | int x = i % packet_size; | |
598 | 1531670 | stat[x]++; | |
599 | 1531670 | stat_all++; | |
600 |
2/2✓ Branch 0 taken 117148 times.
✓ Branch 1 taken 1414522 times.
|
1531670 | if (stat[x] > best_score) { |
601 | 117148 | best_score = stat[x]; | |
602 | } | ||
603 | } | ||
604 | } | ||
605 | } | ||
606 | |||
607 | 69618 | return best_score - FFMAX(stat_all - 10*best_score, 0)/10; | |
608 | } | ||
609 | |||
610 | /* autodetect fec presence */ | ||
611 | 112 | static int get_packet_size(AVFormatContext* s) | |
612 | { | ||
613 | int score, fec_score, dvhs_score; | ||
614 | int margin; | ||
615 | int ret; | ||
616 | |||
617 | /*init buffer to store stream for probing */ | ||
618 | 112 | uint8_t buf[PROBE_PACKET_MAX_BUF] = {0}; | |
619 | 112 | int buf_size = 0; | |
620 | 112 | int max_iterations = 16; | |
621 | |||
622 |
2/4✓ Branch 0 taken 112 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 112 times.
✗ Branch 3 not taken.
|
112 | while (buf_size < PROBE_PACKET_MAX_BUF && max_iterations--) { |
623 | 112 | ret = avio_read_partial(s->pb, buf + buf_size, PROBE_PACKET_MAX_BUF - buf_size); | |
624 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 112 times.
|
112 | if (ret < 0) |
625 | ✗ | return AVERROR_INVALIDDATA; | |
626 | 112 | buf_size += ret; | |
627 | |||
628 | 112 | score = analyze(buf, buf_size, TS_PACKET_SIZE, 0); | |
629 | 112 | dvhs_score = analyze(buf, buf_size, TS_DVHS_PACKET_SIZE, 0); | |
630 | 112 | fec_score = analyze(buf, buf_size, TS_FEC_PACKET_SIZE, 0); | |
631 | 112 | av_log(s, AV_LOG_TRACE, "Probe: %d, score: %d, dvhs_score: %d, fec_score: %d \n", | |
632 | buf_size, score, dvhs_score, fec_score); | ||
633 | |||
634 | 112 | margin = mid_pred(score, fec_score, dvhs_score); | |
635 | |||
636 |
2/2✓ Branch 0 taken 1 times.
✓ Branch 1 taken 111 times.
|
112 | if (buf_size < PROBE_PACKET_MAX_BUF) |
637 | 1 | margin += PROBE_PACKET_MARGIN; /*if buffer not filled */ | |
638 | |||
639 |
1/2✓ Branch 0 taken 112 times.
✗ Branch 1 not taken.
|
112 | if (score > margin) |
640 | 112 | return TS_PACKET_SIZE; | |
641 | ✗ | else if (dvhs_score > margin) | |
642 | ✗ | return TS_DVHS_PACKET_SIZE; | |
643 | ✗ | else if (fec_score > margin) | |
644 | ✗ | return TS_FEC_PACKET_SIZE; | |
645 | } | ||
646 | ✗ | return AVERROR_INVALIDDATA; | |
647 | } | ||
648 | |||
649 | typedef struct SectionHeader { | ||
650 | uint8_t tid; | ||
651 | uint16_t id; | ||
652 | uint8_t version; | ||
653 | uint8_t current_next; | ||
654 | uint8_t sec_num; | ||
655 | uint8_t last_sec_num; | ||
656 | } SectionHeader; | ||
657 | |||
658 | 5726 | static int skip_identical(const SectionHeader *h, MpegTSSectionFilter *tssf) | |
659 | { | ||
660 |
3/4✓ Branch 0 taken 5153 times.
✓ Branch 1 taken 573 times.
✓ Branch 2 taken 5153 times.
✗ Branch 3 not taken.
|
5726 | if (h->version == tssf->last_ver && tssf->last_crc == tssf->crc) |
661 | 5153 | return 1; | |
662 | |||
663 | 573 | tssf->last_ver = h->version; | |
664 | 573 | tssf->last_crc = tssf->crc; | |
665 | |||
666 | 573 | return 0; | |
667 | } | ||
668 | |||
669 | 30630 | static inline int get8(const uint8_t **pp, const uint8_t *p_end) | |
670 | { | ||
671 | const uint8_t *p; | ||
672 | int c; | ||
673 | |||
674 | 30630 | p = *pp; | |
675 |
2/2✓ Branch 0 taken 1373 times.
✓ Branch 1 taken 29257 times.
|
30630 | if (p >= p_end) |
676 | 1373 | return AVERROR_INVALIDDATA; | |
677 | 29257 | c = *p++; | |
678 | 29257 | *pp = p; | |
679 | 29257 | return c; | |
680 | } | ||
681 | |||
682 | 9486 | static inline int get16(const uint8_t **pp, const uint8_t *p_end) | |
683 | { | ||
684 | const uint8_t *p; | ||
685 | int c; | ||
686 | |||
687 | 9486 | p = *pp; | |
688 |
2/2✓ Branch 0 taken 310 times.
✓ Branch 1 taken 9176 times.
|
9486 | if (1 >= p_end - p) |
689 | 310 | return AVERROR_INVALIDDATA; | |
690 | 9176 | c = AV_RB16(p); | |
691 | 9176 | p += 2; | |
692 | 9176 | *pp = p; | |
693 | 9176 | return c; | |
694 | } | ||
695 | |||
696 | /* read and allocate a DVB string preceded by its length */ | ||
697 | 200 | static char *getstr8(const uint8_t **pp, const uint8_t *p_end) | |
698 | { | ||
699 | int len; | ||
700 | const uint8_t *p; | ||
701 | char *str; | ||
702 | |||
703 | 200 | p = *pp; | |
704 | 200 | len = get8(&p, p_end); | |
705 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 200 times.
|
200 | if (len < 0) |
706 | ✗ | return NULL; | |
707 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 200 times.
|
200 | if (len > p_end - p) |
708 | ✗ | return NULL; | |
709 | #if CONFIG_ICONV | ||
710 |
1/2✓ Branch 0 taken 200 times.
✗ Branch 1 not taken.
|
200 | if (len) { |
711 | 200 | const char *encodings[] = { | |
712 | "ISO6937", "ISO-8859-5", "ISO-8859-6", "ISO-8859-7", | ||
713 | "ISO-8859-8", "ISO-8859-9", "ISO-8859-10", "ISO-8859-11", | ||
714 | "", "ISO-8859-13", "ISO-8859-14", "ISO-8859-15", "", "", "", "", | ||
715 | "", "UCS-2BE", "KSC_5601", "GB2312", "UCS-2BE", "UTF-8", "", "", | ||
716 | "", "", "", "", "", "", "", "" | ||
717 | }; | ||
718 | iconv_t cd; | ||
719 | char *in, *out; | ||
720 | 200 | size_t inlen = len, outlen = inlen * 6 + 1; | |
721 |
2/12✓ Branch 0 taken 200 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 200 times.
✗ Branch 4 not taken.
✗ Branch 5 not taken.
✗ Branch 6 not taken.
✗ Branch 7 not taken.
✗ Branch 8 not taken.
✗ Branch 9 not taken.
✗ Branch 10 not taken.
✗ Branch 11 not taken.
|
200 | if (len >= 3 && p[0] == 0x10 && !p[1] && p[2] && p[2] <= 0xf && p[2] != 0xc) { |
722 | char iso8859[12]; | ||
723 | ✗ | snprintf(iso8859, sizeof(iso8859), "ISO-8859-%d", p[2]); | |
724 | ✗ | inlen -= 3; | |
725 | ✗ | in = (char *)p + 3; | |
726 | ✗ | cd = iconv_open("UTF-8", iso8859); | |
727 |
2/2✓ Branch 0 taken 8 times.
✓ Branch 1 taken 192 times.
|
200 | } else if (p[0] < 0x20) { |
728 | 8 | inlen -= 1; | |
729 | 8 | in = (char *)p + 1; | |
730 | 8 | cd = iconv_open("UTF-8", encodings[*p]); | |
731 | } else { | ||
732 | 192 | in = (char *)p; | |
733 | 192 | cd = iconv_open("UTF-8", encodings[0]); | |
734 | } | ||
735 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 200 times.
|
200 | if (cd == (iconv_t)-1) |
736 | ✗ | goto no_iconv; | |
737 | 200 | str = out = av_malloc(outlen); | |
738 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 200 times.
|
200 | if (!str) { |
739 | ✗ | iconv_close(cd); | |
740 | 200 | return NULL; | |
741 | } | ||
742 |
1/2✗ Branch 1 not taken.
✓ Branch 2 taken 200 times.
|
200 | if (iconv(cd, &in, &inlen, &out, &outlen) == -1) { |
743 | ✗ | iconv_close(cd); | |
744 | ✗ | av_freep(&str); | |
745 | ✗ | goto no_iconv; | |
746 | } | ||
747 | 200 | iconv_close(cd); | |
748 | 200 | *out = 0; | |
749 | 200 | *pp = p + len; | |
750 | 200 | return str; | |
751 | } | ||
752 | ✗ | no_iconv: | |
753 | #endif | ||
754 | ✗ | str = av_malloc(len + 1); | |
755 | ✗ | if (!str) | |
756 | ✗ | return NULL; | |
757 | ✗ | memcpy(str, p, len); | |
758 | ✗ | str[len] = '\0'; | |
759 | ✗ | p += len; | |
760 | ✗ | *pp = p; | |
761 | ✗ | return str; | |
762 | } | ||
763 | |||
764 | 6369 | static int parse_section_header(SectionHeader *h, | |
765 | const uint8_t **pp, const uint8_t *p_end) | ||
766 | { | ||
767 | int val; | ||
768 | |||
769 | 6369 | val = get8(pp, p_end); | |
770 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 6369 times.
|
6369 | if (val < 0) |
771 | ✗ | return val; | |
772 | 6369 | h->tid = val; | |
773 | 6369 | *pp += 2; | |
774 | 6369 | val = get16(pp, p_end); | |
775 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 6369 times.
|
6369 | if (val < 0) |
776 | ✗ | return val; | |
777 | 6369 | h->id = val; | |
778 | 6369 | val = get8(pp, p_end); | |
779 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 6369 times.
|
6369 | if (val < 0) |
780 | ✗ | return val; | |
781 | 6369 | h->version = (val >> 1) & 0x1f; | |
782 | 6369 | h->current_next = val & 0x01; | |
783 | 6369 | val = get8(pp, p_end); | |
784 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 6369 times.
|
6369 | if (val < 0) |
785 | ✗ | return val; | |
786 | 6369 | h->sec_num = val; | |
787 | 6369 | val = get8(pp, p_end); | |
788 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 6369 times.
|
6369 | if (val < 0) |
789 | ✗ | return val; | |
790 | 6369 | h->last_sec_num = val; | |
791 | 6369 | return 0; | |
792 | } | ||
793 | |||
794 | typedef struct StreamType { | ||
795 | uint32_t stream_type; | ||
796 | enum AVMediaType codec_type; | ||
797 | enum AVCodecID codec_id; | ||
798 | } StreamType; | ||
799 | |||
800 | static const StreamType ISO_types[] = { | ||
801 | { 0x01, AVMEDIA_TYPE_VIDEO, AV_CODEC_ID_MPEG2VIDEO }, | ||
802 | { 0x02, AVMEDIA_TYPE_VIDEO, AV_CODEC_ID_MPEG2VIDEO }, | ||
803 | { 0x03, AVMEDIA_TYPE_AUDIO, AV_CODEC_ID_MP3 }, | ||
804 | { 0x04, AVMEDIA_TYPE_AUDIO, AV_CODEC_ID_MP3 }, | ||
805 | { 0x0f, AVMEDIA_TYPE_AUDIO, AV_CODEC_ID_AAC }, | ||
806 | { 0x10, AVMEDIA_TYPE_VIDEO, AV_CODEC_ID_MPEG4 }, | ||
807 | /* Makito encoder sets stream type 0x11 for AAC, | ||
808 | * so auto-detect LOAS/LATM instead of hardcoding it. */ | ||
809 | #if !CONFIG_LOAS_DEMUXER | ||
810 | { 0x11, AVMEDIA_TYPE_AUDIO, AV_CODEC_ID_AAC_LATM }, /* LATM syntax */ | ||
811 | #endif | ||
812 | { 0x1b, AVMEDIA_TYPE_VIDEO, AV_CODEC_ID_H264 }, | ||
813 | { 0x1c, AVMEDIA_TYPE_AUDIO, AV_CODEC_ID_AAC }, | ||
814 | { 0x20, AVMEDIA_TYPE_VIDEO, AV_CODEC_ID_H264 }, | ||
815 | { 0x21, AVMEDIA_TYPE_VIDEO, AV_CODEC_ID_JPEG2000 }, | ||
816 | { 0x24, AVMEDIA_TYPE_VIDEO, AV_CODEC_ID_HEVC }, | ||
817 | { 0x33, AVMEDIA_TYPE_VIDEO, AV_CODEC_ID_VVC }, | ||
818 | { 0x42, AVMEDIA_TYPE_VIDEO, AV_CODEC_ID_CAVS }, | ||
819 | { 0xd1, AVMEDIA_TYPE_VIDEO, AV_CODEC_ID_DIRAC }, | ||
820 | { 0xd2, AVMEDIA_TYPE_VIDEO, AV_CODEC_ID_AVS2 }, | ||
821 | { 0xd4, AVMEDIA_TYPE_VIDEO, AV_CODEC_ID_AVS3 }, | ||
822 | { 0xea, AVMEDIA_TYPE_VIDEO, AV_CODEC_ID_VC1 }, | ||
823 | { 0 }, | ||
824 | }; | ||
825 | |||
826 | static const StreamType HDMV_types[] = { | ||
827 | { 0x80, AVMEDIA_TYPE_AUDIO, AV_CODEC_ID_PCM_BLURAY }, | ||
828 | { 0x81, AVMEDIA_TYPE_AUDIO, AV_CODEC_ID_AC3 }, | ||
829 | { 0x82, AVMEDIA_TYPE_AUDIO, AV_CODEC_ID_DTS }, | ||
830 | { 0x83, AVMEDIA_TYPE_AUDIO, AV_CODEC_ID_TRUEHD }, | ||
831 | { 0x84, AVMEDIA_TYPE_AUDIO, AV_CODEC_ID_EAC3 }, | ||
832 | { 0x85, AVMEDIA_TYPE_AUDIO, AV_CODEC_ID_DTS }, /* DTS HD */ | ||
833 | { 0x86, AVMEDIA_TYPE_AUDIO, AV_CODEC_ID_DTS }, /* DTS HD MASTER*/ | ||
834 | { 0xa1, AVMEDIA_TYPE_AUDIO, AV_CODEC_ID_EAC3 }, /* E-AC3 Secondary Audio */ | ||
835 | { 0xa2, AVMEDIA_TYPE_AUDIO, AV_CODEC_ID_DTS }, /* DTS Express Secondary Audio */ | ||
836 | { 0x90, AVMEDIA_TYPE_SUBTITLE, AV_CODEC_ID_HDMV_PGS_SUBTITLE }, | ||
837 | { 0x92, AVMEDIA_TYPE_SUBTITLE, AV_CODEC_ID_HDMV_TEXT_SUBTITLE }, | ||
838 | { 0 }, | ||
839 | }; | ||
840 | |||
841 | /* SCTE types */ | ||
842 | static const StreamType SCTE_types[] = { | ||
843 | { 0x86, AVMEDIA_TYPE_DATA, AV_CODEC_ID_SCTE_35 }, | ||
844 | { 0 }, | ||
845 | }; | ||
846 | |||
847 | /* ATSC ? */ | ||
848 | static const StreamType MISC_types[] = { | ||
849 | { 0x81, AVMEDIA_TYPE_AUDIO, AV_CODEC_ID_AC3 }, | ||
850 | { 0x8a, AVMEDIA_TYPE_AUDIO, AV_CODEC_ID_DTS }, | ||
851 | { 0 }, | ||
852 | }; | ||
853 | |||
854 | /* HLS Sample Encryption Types */ | ||
855 | static const StreamType HLS_SAMPLE_ENC_types[] = { | ||
856 | { 0xdb, AVMEDIA_TYPE_VIDEO, AV_CODEC_ID_H264}, | ||
857 | { 0xcf, AVMEDIA_TYPE_AUDIO, AV_CODEC_ID_AAC }, | ||
858 | { 0xc1, AVMEDIA_TYPE_AUDIO, AV_CODEC_ID_AC3 }, | ||
859 | { 0xc2, AVMEDIA_TYPE_AUDIO, AV_CODEC_ID_EAC3}, | ||
860 | { 0 }, | ||
861 | }; | ||
862 | |||
863 | static const StreamType REGD_types[] = { | ||
864 | { MKTAG('d', 'r', 'a', 'c'), AVMEDIA_TYPE_VIDEO, AV_CODEC_ID_DIRAC }, | ||
865 | { MKTAG('A', 'C', '-', '3'), AVMEDIA_TYPE_AUDIO, AV_CODEC_ID_AC3 }, | ||
866 | { MKTAG('A', 'C', '-', '4'), AVMEDIA_TYPE_AUDIO, AV_CODEC_ID_AC4 }, | ||
867 | { MKTAG('B', 'S', 'S', 'D'), AVMEDIA_TYPE_AUDIO, AV_CODEC_ID_S302M }, | ||
868 | { MKTAG('D', 'T', 'S', '1'), AVMEDIA_TYPE_AUDIO, AV_CODEC_ID_DTS }, | ||
869 | { MKTAG('D', 'T', 'S', '2'), AVMEDIA_TYPE_AUDIO, AV_CODEC_ID_DTS }, | ||
870 | { MKTAG('D', 'T', 'S', '3'), AVMEDIA_TYPE_AUDIO, AV_CODEC_ID_DTS }, | ||
871 | { MKTAG('E', 'A', 'C', '3'), AVMEDIA_TYPE_AUDIO, AV_CODEC_ID_EAC3 }, | ||
872 | { MKTAG('H', 'E', 'V', 'C'), AVMEDIA_TYPE_VIDEO, AV_CODEC_ID_HEVC }, | ||
873 | { MKTAG('V', 'V', 'C', ' '), AVMEDIA_TYPE_VIDEO, AV_CODEC_ID_VVC }, | ||
874 | { MKTAG('K', 'L', 'V', 'A'), AVMEDIA_TYPE_DATA, AV_CODEC_ID_SMPTE_KLV }, | ||
875 | { MKTAG('V', 'A', 'N', 'C'), AVMEDIA_TYPE_DATA, AV_CODEC_ID_SMPTE_2038 }, | ||
876 | { MKTAG('I', 'D', '3', ' '), AVMEDIA_TYPE_DATA, AV_CODEC_ID_TIMED_ID3 }, | ||
877 | { MKTAG('V', 'C', '-', '1'), AVMEDIA_TYPE_VIDEO, AV_CODEC_ID_VC1 }, | ||
878 | { MKTAG('O', 'p', 'u', 's'), AVMEDIA_TYPE_AUDIO, AV_CODEC_ID_OPUS }, | ||
879 | { 0 }, | ||
880 | }; | ||
881 | |||
882 | static const StreamType METADATA_types[] = { | ||
883 | { MKTAG('K','L','V','A'), AVMEDIA_TYPE_DATA, AV_CODEC_ID_SMPTE_KLV }, | ||
884 | { MKTAG('I','D','3',' '), AVMEDIA_TYPE_DATA, AV_CODEC_ID_TIMED_ID3 }, | ||
885 | { 0 }, | ||
886 | }; | ||
887 | |||
888 | /* descriptor present */ | ||
889 | static const StreamType DESC_types[] = { | ||
890 | { 0x6a, AVMEDIA_TYPE_AUDIO, AV_CODEC_ID_AC3 }, /* AC-3 descriptor */ | ||
891 | { 0x7a, AVMEDIA_TYPE_AUDIO, AV_CODEC_ID_EAC3 }, /* E-AC-3 descriptor */ | ||
892 | { 0x7b, AVMEDIA_TYPE_AUDIO, AV_CODEC_ID_DTS }, | ||
893 | { 0x56, AVMEDIA_TYPE_SUBTITLE, AV_CODEC_ID_DVB_TELETEXT }, | ||
894 | { 0x59, AVMEDIA_TYPE_SUBTITLE, AV_CODEC_ID_DVB_SUBTITLE }, /* subtitling descriptor */ | ||
895 | { 0 }, | ||
896 | }; | ||
897 | |||
898 | 149 | static void mpegts_find_stream_type(AVStream *st, | |
899 | uint32_t stream_type, | ||
900 | const StreamType *types) | ||
901 | { | ||
902 | 149 | FFStream *const sti = ffstream(st); | |
903 |
2/2✓ Branch 0 taken 780 times.
✓ Branch 1 taken 47 times.
|
827 | for (; types->stream_type; types++) |
904 |
2/2✓ Branch 0 taken 102 times.
✓ Branch 1 taken 678 times.
|
780 | if (stream_type == types->stream_type) { |
905 |
2/2✓ Branch 0 taken 8 times.
✓ Branch 1 taken 94 times.
|
102 | if (st->codecpar->codec_type != types->codec_type || |
906 |
2/2✓ Branch 0 taken 7 times.
✓ Branch 1 taken 1 times.
|
8 | st->codecpar->codec_id != types->codec_id) { |
907 | 101 | st->codecpar->codec_type = types->codec_type; | |
908 | 101 | st->codecpar->codec_id = types->codec_id; | |
909 | 101 | sti->need_context_update = 1; | |
910 | } | ||
911 | 102 | sti->request_probe = 0; | |
912 | 102 | return; | |
913 | } | ||
914 | } | ||
915 | |||
916 | 97 | static int mpegts_set_stream_info(AVStream *st, PESContext *pes, | |
917 | uint32_t stream_type, uint32_t prog_reg_desc) | ||
918 | { | ||
919 | 97 | FFStream *const sti = ffstream(st); | |
920 | 97 | int old_codec_type = st->codecpar->codec_type; | |
921 | 97 | int old_codec_id = st->codecpar->codec_id; | |
922 | 97 | int old_codec_tag = st->codecpar->codec_tag; | |
923 | |||
924 | 97 | avpriv_set_pts_info(st, 33, 1, 90000); | |
925 | 97 | st->priv_data = pes; | |
926 | 97 | st->codecpar->codec_type = AVMEDIA_TYPE_DATA; | |
927 | 97 | st->codecpar->codec_id = AV_CODEC_ID_NONE; | |
928 | 97 | sti->need_parsing = AVSTREAM_PARSE_FULL; | |
929 | 97 | pes->st = st; | |
930 | 97 | pes->stream_type = stream_type; | |
931 | |||
932 | 97 | av_log(pes->stream, AV_LOG_DEBUG, | |
933 | "stream=%d stream_type=%x pid=%x prog_reg_desc=%.4s\n", | ||
934 | st->index, pes->stream_type, pes->pid, (char *)&prog_reg_desc); | ||
935 | |||
936 | 97 | st->codecpar->codec_tag = pes->stream_type; | |
937 | |||
938 | 97 | mpegts_find_stream_type(st, pes->stream_type, ISO_types); | |
939 |
4/4✓ Branch 0 taken 93 times.
✓ Branch 1 taken 4 times.
✓ Branch 2 taken 3 times.
✓ Branch 3 taken 90 times.
|
97 | if (pes->stream_type == 4 || pes->stream_type == 0x0f) |
940 | 7 | sti->request_probe = 50; | |
941 |
1/2✓ Branch 0 taken 97 times.
✗ Branch 1 not taken.
|
97 | if ((prog_reg_desc == AV_RL32("HDMV") || |
942 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 97 times.
|
97 | prog_reg_desc == AV_RL32("HDPR")) && |
943 | ✗ | st->codecpar->codec_id == AV_CODEC_ID_NONE) { | |
944 | ✗ | mpegts_find_stream_type(st, pes->stream_type, HDMV_types); | |
945 | ✗ | if (pes->stream_type == 0x83) { | |
946 | // HDMV TrueHD streams also contain an AC3 coded version of the | ||
947 | // audio track - add a second stream for this | ||
948 | AVStream *sub_st; | ||
949 | // priv_data cannot be shared between streams | ||
950 | ✗ | PESContext *sub_pes = av_memdup(pes, sizeof(*sub_pes)); | |
951 | ✗ | if (!sub_pes) | |
952 | ✗ | return AVERROR(ENOMEM); | |
953 | |||
954 | ✗ | sub_st = avformat_new_stream(pes->stream, NULL); | |
955 | ✗ | if (!sub_st) { | |
956 | ✗ | av_free(sub_pes); | |
957 | ✗ | return AVERROR(ENOMEM); | |
958 | } | ||
959 | |||
960 | ✗ | sub_st->id = pes->pid; | |
961 | ✗ | avpriv_set_pts_info(sub_st, 33, 1, 90000); | |
962 | ✗ | sub_st->priv_data = sub_pes; | |
963 | ✗ | sub_st->codecpar->codec_type = AVMEDIA_TYPE_AUDIO; | |
964 | ✗ | sub_st->codecpar->codec_id = AV_CODEC_ID_AC3; | |
965 | ✗ | ffstream(sub_st)->need_parsing = AVSTREAM_PARSE_FULL; | |
966 | ✗ | sub_pes->sub_st = pes->sub_st = sub_st; | |
967 | } | ||
968 | } | ||
969 |
2/2✓ Branch 0 taken 23 times.
✓ Branch 1 taken 74 times.
|
97 | if (st->codecpar->codec_id == AV_CODEC_ID_NONE) |
970 | 23 | mpegts_find_stream_type(st, pes->stream_type, MISC_types); | |
971 |
2/2✓ Branch 0 taken 8 times.
✓ Branch 1 taken 89 times.
|
97 | if (st->codecpar->codec_id == AV_CODEC_ID_NONE) |
972 | 8 | mpegts_find_stream_type(st, pes->stream_type, HLS_SAMPLE_ENC_types); | |
973 |
2/2✓ Branch 0 taken 8 times.
✓ Branch 1 taken 89 times.
|
97 | if (st->codecpar->codec_id == AV_CODEC_ID_NONE) { |
974 | 8 | st->codecpar->codec_id = old_codec_id; | |
975 | 8 | st->codecpar->codec_type = old_codec_type; | |
976 | } | ||
977 |
2/2✓ Branch 0 taken 89 times.
✓ Branch 1 taken 8 times.
|
97 | if ((st->codecpar->codec_id == AV_CODEC_ID_NONE || |
978 |
3/4✓ Branch 0 taken 7 times.
✓ Branch 1 taken 82 times.
✗ Branch 2 not taken.
✓ Branch 3 taken 7 times.
|
89 | (sti->request_probe > 0 && sti->request_probe < AVPROBE_SCORE_STREAM_RETRY / 5)) && |
979 |
3/4✓ Branch 0 taken 8 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 5 times.
✓ Branch 3 taken 3 times.
|
8 | sti->probe_packets > 0 && |
980 | stream_type == STREAM_TYPE_PRIVATE_DATA) { | ||
981 | 5 | st->codecpar->codec_type = AVMEDIA_TYPE_DATA; | |
982 | 5 | st->codecpar->codec_id = AV_CODEC_ID_BIN_DATA; | |
983 | 5 | sti->request_probe = AVPROBE_SCORE_STREAM_RETRY / 5; | |
984 | } | ||
985 | |||
986 | /* queue a context update if properties changed */ | ||
987 |
2/2✓ Branch 0 taken 3 times.
✓ Branch 1 taken 94 times.
|
97 | if (old_codec_type != st->codecpar->codec_type || |
988 |
1/2✓ Branch 0 taken 3 times.
✗ Branch 1 not taken.
|
3 | old_codec_id != st->codecpar->codec_id || |
989 |
1/2✓ Branch 0 taken 3 times.
✗ Branch 1 not taken.
|
3 | old_codec_tag != st->codecpar->codec_tag) |
990 | 97 | sti->need_context_update = 1; | |
991 | |||
992 | 97 | return 0; | |
993 | } | ||
994 | |||
995 | 55460 | static void reset_pes_packet_state(PESContext *pes) | |
996 | { | ||
997 | 55460 | pes->pts = AV_NOPTS_VALUE; | |
998 | 55460 | pes->dts = AV_NOPTS_VALUE; | |
999 | 55460 | pes->data_index = 0; | |
1000 | 55460 | pes->flags = 0; | |
1001 | 55460 | av_buffer_unref(&pes->buffer); | |
1002 | 55460 | } | |
1003 | |||
1004 | 12 | static void new_data_packet(const uint8_t *buffer, int len, AVPacket *pkt) | |
1005 | { | ||
1006 | 12 | av_packet_unref(pkt); | |
1007 | 12 | pkt->data = (uint8_t *)buffer; | |
1008 | 12 | pkt->size = len; | |
1009 | 12 | } | |
1010 | |||
1011 | 28806 | static int new_pes_packet(PESContext *pes, AVPacket *pkt) | |
1012 | { | ||
1013 | uint8_t *sd; | ||
1014 | |||
1015 | 28806 | av_packet_unref(pkt); | |
1016 | |||
1017 | 28806 | pkt->buf = pes->buffer; | |
1018 | 28806 | pkt->data = pes->buffer->data; | |
1019 | 28806 | pkt->size = pes->data_index; | |
1020 | |||
1021 |
2/2✓ Branch 0 taken 25900 times.
✓ Branch 1 taken 2906 times.
|
28806 | if (pes->PES_packet_length && |
1022 |
2/2✓ Branch 0 taken 83 times.
✓ Branch 1 taken 25817 times.
|
25900 | pes->pes_header_size + pes->data_index != pes->PES_packet_length + |
1023 | PES_START_SIZE) { | ||
1024 | 83 | av_log(pes->stream, AV_LOG_WARNING, "PES packet size mismatch\n"); | |
1025 | 83 | pes->flags |= AV_PKT_FLAG_CORRUPT; | |
1026 | } | ||
1027 | 28806 | memset(pkt->data + pkt->size, 0, AV_INPUT_BUFFER_PADDING_SIZE); | |
1028 | |||
1029 | // Separate out the AC3 substream from an HDMV combined TrueHD/AC3 PID | ||
1030 |
1/6✗ Branch 0 not taken.
✓ Branch 1 taken 28806 times.
✗ Branch 2 not taken.
✗ Branch 3 not taken.
✗ Branch 4 not taken.
✗ Branch 5 not taken.
|
28806 | if (pes->sub_st && pes->stream_type == 0x83 && pes->extended_stream_id == 0x76) |
1031 | ✗ | pkt->stream_index = pes->sub_st->index; | |
1032 | else | ||
1033 | 28806 | pkt->stream_index = pes->st->index; | |
1034 | 28806 | pkt->pts = pes->pts; | |
1035 | 28806 | pkt->dts = pes->dts; | |
1036 | /* store position of first TS packet of this PES packet */ | ||
1037 | 28806 | pkt->pos = pes->ts_packet_pos; | |
1038 | 28806 | pkt->flags = pes->flags; | |
1039 | |||
1040 | 28806 | pes->buffer = NULL; | |
1041 | 28806 | reset_pes_packet_state(pes); | |
1042 | |||
1043 | 28806 | sd = av_packet_new_side_data(pkt, AV_PKT_DATA_MPEGTS_STREAM_ID, 1); | |
1044 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 28806 times.
|
28806 | if (!sd) |
1045 | ✗ | return AVERROR(ENOMEM); | |
1046 | 28806 | *sd = pes->stream_id; | |
1047 | |||
1048 | 28806 | return 0; | |
1049 | } | ||
1050 | |||
1051 | ✗ | static uint64_t get_ts64(GetBitContext *gb, int bits) | |
1052 | { | ||
1053 | ✗ | if (get_bits_left(gb) < bits) | |
1054 | ✗ | return AV_NOPTS_VALUE; | |
1055 | ✗ | return get_bits64(gb, bits); | |
1056 | } | ||
1057 | |||
1058 | ✗ | static int read_sl_header(PESContext *pes, SLConfigDescr *sl, | |
1059 | const uint8_t *buf, int buf_size) | ||
1060 | { | ||
1061 | GetBitContext gb; | ||
1062 | ✗ | int au_start_flag = 0, au_end_flag = 0, ocr_flag = 0, idle_flag = 0; | |
1063 | ✗ | int padding_flag = 0, padding_bits = 0, inst_bitrate_flag = 0; | |
1064 | ✗ | int dts_flag = -1, cts_flag = -1; | |
1065 | ✗ | int64_t dts = AV_NOPTS_VALUE, cts = AV_NOPTS_VALUE; | |
1066 | uint8_t buf_padded[128 + AV_INPUT_BUFFER_PADDING_SIZE]; | ||
1067 | ✗ | int buf_padded_size = FFMIN(buf_size, sizeof(buf_padded) - AV_INPUT_BUFFER_PADDING_SIZE); | |
1068 | |||
1069 | ✗ | memcpy(buf_padded, buf, buf_padded_size); | |
1070 | |||
1071 | ✗ | init_get_bits(&gb, buf_padded, buf_padded_size * 8); | |
1072 | |||
1073 | ✗ | if (sl->use_au_start) | |
1074 | ✗ | au_start_flag = get_bits1(&gb); | |
1075 | ✗ | if (sl->use_au_end) | |
1076 | ✗ | au_end_flag = get_bits1(&gb); | |
1077 | ✗ | if (!sl->use_au_start && !sl->use_au_end) | |
1078 | ✗ | au_start_flag = au_end_flag = 1; | |
1079 | ✗ | if (sl->ocr_len > 0) | |
1080 | ✗ | ocr_flag = get_bits1(&gb); | |
1081 | ✗ | if (sl->use_idle) | |
1082 | ✗ | idle_flag = get_bits1(&gb); | |
1083 | ✗ | if (sl->use_padding) | |
1084 | ✗ | padding_flag = get_bits1(&gb); | |
1085 | ✗ | if (padding_flag) | |
1086 | ✗ | padding_bits = get_bits(&gb, 3); | |
1087 | |||
1088 | ✗ | if (!idle_flag && (!padding_flag || padding_bits != 0)) { | |
1089 | ✗ | if (sl->packet_seq_num_len) | |
1090 | ✗ | skip_bits_long(&gb, sl->packet_seq_num_len); | |
1091 | ✗ | if (sl->degr_prior_len) | |
1092 | ✗ | if (get_bits1(&gb)) | |
1093 | ✗ | skip_bits(&gb, sl->degr_prior_len); | |
1094 | ✗ | if (ocr_flag) | |
1095 | ✗ | skip_bits_long(&gb, sl->ocr_len); | |
1096 | ✗ | if (au_start_flag) { | |
1097 | ✗ | if (sl->use_rand_acc_pt) | |
1098 | ✗ | get_bits1(&gb); | |
1099 | ✗ | if (sl->au_seq_num_len > 0) | |
1100 | ✗ | skip_bits_long(&gb, sl->au_seq_num_len); | |
1101 | ✗ | if (sl->use_timestamps) { | |
1102 | ✗ | dts_flag = get_bits1(&gb); | |
1103 | ✗ | cts_flag = get_bits1(&gb); | |
1104 | } | ||
1105 | } | ||
1106 | ✗ | if (sl->inst_bitrate_len) | |
1107 | ✗ | inst_bitrate_flag = get_bits1(&gb); | |
1108 | ✗ | if (dts_flag == 1) | |
1109 | ✗ | dts = get_ts64(&gb, sl->timestamp_len); | |
1110 | ✗ | if (cts_flag == 1) | |
1111 | ✗ | cts = get_ts64(&gb, sl->timestamp_len); | |
1112 | ✗ | if (sl->au_len > 0) | |
1113 | ✗ | skip_bits_long(&gb, sl->au_len); | |
1114 | ✗ | if (inst_bitrate_flag) | |
1115 | ✗ | skip_bits_long(&gb, sl->inst_bitrate_len); | |
1116 | } | ||
1117 | |||
1118 | ✗ | if (dts != AV_NOPTS_VALUE) | |
1119 | ✗ | pes->dts = dts; | |
1120 | ✗ | if (cts != AV_NOPTS_VALUE) | |
1121 | ✗ | pes->pts = cts; | |
1122 | |||
1123 | ✗ | if (sl->timestamp_len && sl->timestamp_res) | |
1124 | ✗ | avpriv_set_pts_info(pes->st, sl->timestamp_len, 1, sl->timestamp_res); | |
1125 | |||
1126 | ✗ | return (get_bits_count(&gb) + 7) >> 3; | |
1127 | } | ||
1128 | |||
1129 | 28902 | static AVBufferRef *buffer_pool_get(MpegTSContext *ts, int size) | |
1130 | { | ||
1131 | 28902 | int index = av_log2(size + AV_INPUT_BUFFER_PADDING_SIZE); | |
1132 |
2/2✓ Branch 0 taken 155 times.
✓ Branch 1 taken 28747 times.
|
28902 | if (!ts->pools[index]) { |
1133 |
2/2✓ Branch 0 taken 131 times.
✓ Branch 1 taken 24 times.
|
155 | int pool_size = FFMIN(ts->max_packet_size + AV_INPUT_BUFFER_PADDING_SIZE, 2 << index); |
1134 | 155 | ts->pools[index] = av_buffer_pool_init(pool_size, NULL); | |
1135 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 155 times.
|
155 | if (!ts->pools[index]) |
1136 | ✗ | return NULL; | |
1137 | } | ||
1138 | 28902 | return av_buffer_pool_get(ts->pools[index]); | |
1139 | } | ||
1140 | |||
1141 | /* return non zero if a packet could be constructed */ | ||
1142 | 366641 | static int mpegts_push_data(MpegTSFilter *filter, | |
1143 | const uint8_t *buf, int buf_size, int is_start, | ||
1144 | int64_t pos) | ||
1145 | { | ||
1146 | 366641 | PESContext *pes = filter->u.pes_filter.opaque; | |
1147 | 366641 | MpegTSContext *ts = pes->ts; | |
1148 | const uint8_t *p; | ||
1149 | int ret, len; | ||
1150 | |||
1151 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 366641 times.
|
366641 | if (!ts->pkt) |
1152 | ✗ | return 0; | |
1153 | |||
1154 |
2/2✓ Branch 0 taken 29492 times.
✓ Branch 1 taken 337149 times.
|
366641 | if (is_start) { |
1155 |
3/4✓ Branch 0 taken 2838 times.
✓ Branch 1 taken 26654 times.
✓ Branch 2 taken 2838 times.
✗ Branch 3 not taken.
|
29492 | if (pes->state == MPEGTS_PAYLOAD && pes->data_index > 0) { |
1156 | 2838 | ret = new_pes_packet(pes, ts->pkt); | |
1157 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 2838 times.
|
2838 | if (ret < 0) |
1158 | ✗ | return ret; | |
1159 | 2838 | ts->stop_parse = 1; | |
1160 | } else { | ||
1161 | 26654 | reset_pes_packet_state(pes); | |
1162 | } | ||
1163 | 29492 | pes->state = MPEGTS_HEADER; | |
1164 | 29492 | pes->ts_packet_pos = pos; | |
1165 | } | ||
1166 | 366641 | p = buf; | |
1167 |
2/2✓ Branch 0 taken 453935 times.
✓ Branch 1 taken 366641 times.
|
1187217 | while (buf_size > 0) { |
1168 |
5/6✓ Branch 0 taken 29492 times.
✓ Branch 1 taken 28902 times.
✓ Branch 2 taken 28902 times.
✓ Branch 3 taken 350837 times.
✓ Branch 4 taken 15802 times.
✗ Branch 5 not taken.
|
453935 | switch (pes->state) { |
1169 | 29492 | case MPEGTS_HEADER: | |
1170 | 29492 | len = PES_START_SIZE - pes->data_index; | |
1171 |
2/2✓ Branch 0 taken 2 times.
✓ Branch 1 taken 29490 times.
|
29492 | if (len > buf_size) |
1172 | 2 | len = buf_size; | |
1173 | 29492 | memcpy(pes->header + pes->data_index, p, len); | |
1174 | 29492 | pes->data_index += len; | |
1175 | 29492 | p += len; | |
1176 | 29492 | buf_size -= len; | |
1177 |
2/2✓ Branch 0 taken 29490 times.
✓ Branch 1 taken 2 times.
|
29492 | if (pes->data_index == PES_START_SIZE) { |
1178 | /* we got all the PES or section header. We can now | ||
1179 | * decide */ | ||
1180 |
3/4✓ Branch 0 taken 29483 times.
✓ Branch 1 taken 7 times.
✗ Branch 2 not taken.
✓ Branch 3 taken 29483 times.
|
29490 | if (pes->header[0] == 0x00 && pes->header[1] == 0x00 && |
1181 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 29483 times.
|
29483 | pes->header[2] == 0x01) { |
1182 | /* it must be an MPEG-2 PES stream */ | ||
1183 | 29483 | pes->stream_id = pes->header[3]; | |
1184 | 29483 | av_log(pes->stream, AV_LOG_TRACE, "pid=%x stream_id=%#x\n", pes->pid, pes->stream_id); | |
1185 | |||
1186 |
3/4✓ Branch 0 taken 29483 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 581 times.
✓ Branch 3 taken 28902 times.
|
29483 | if ((pes->st && pes->st->discard == AVDISCARD_ALL && |
1187 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 581 times.
|
581 | (!pes->sub_st || |
1188 | ✗ | pes->sub_st->discard == AVDISCARD_ALL)) || | |
1189 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 28902 times.
|
28902 | pes->stream_id == STREAM_ID_PADDING_STREAM) |
1190 | 581 | goto skip; | |
1191 | |||
1192 | /* stream not present in PMT */ | ||
1193 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 28902 times.
|
28902 | if (!pes->st) { |
1194 | ✗ | if (ts->skip_changes) | |
1195 | ✗ | goto skip; | |
1196 | ✗ | if (ts->merge_pmt_versions) | |
1197 | ✗ | goto skip; /* wait for PMT to merge new stream */ | |
1198 | |||
1199 | ✗ | pes->st = avformat_new_stream(ts->stream, NULL); | |
1200 | ✗ | if (!pes->st) | |
1201 | ✗ | return AVERROR(ENOMEM); | |
1202 | ✗ | pes->st->id = pes->pid; | |
1203 | ✗ | mpegts_set_stream_info(pes->st, pes, 0, 0); | |
1204 | } | ||
1205 | |||
1206 | 28902 | pes->PES_packet_length = AV_RB16(pes->header + 4); | |
1207 | /* NOTE: zero length means the PES size is unbounded */ | ||
1208 | |||
1209 |
1/2✓ Branch 0 taken 28902 times.
✗ Branch 1 not taken.
|
28902 | if (pes->stream_id != STREAM_ID_PROGRAM_STREAM_MAP && |
1210 |
1/2✓ Branch 0 taken 28902 times.
✗ Branch 1 not taken.
|
28902 | pes->stream_id != STREAM_ID_PRIVATE_STREAM_2 && |
1211 |
1/2✓ Branch 0 taken 28902 times.
✗ Branch 1 not taken.
|
28902 | pes->stream_id != STREAM_ID_ECM_STREAM && |
1212 |
1/2✓ Branch 0 taken 28902 times.
✗ Branch 1 not taken.
|
28902 | pes->stream_id != STREAM_ID_EMM_STREAM && |
1213 |
1/2✓ Branch 0 taken 28902 times.
✗ Branch 1 not taken.
|
28902 | pes->stream_id != STREAM_ID_PROGRAM_STREAM_DIRECTORY && |
1214 |
1/2✓ Branch 0 taken 28902 times.
✗ Branch 1 not taken.
|
28902 | pes->stream_id != STREAM_ID_DSMCC_STREAM && |
1215 |
1/2✓ Branch 0 taken 28902 times.
✗ Branch 1 not taken.
|
57804 | pes->stream_id != STREAM_ID_TYPE_E_STREAM) { |
1216 | 28902 | FFStream *const pes_sti = ffstream(pes->st); | |
1217 | 28902 | pes->state = MPEGTS_PESHEADER; | |
1218 |
3/4✓ Branch 0 taken 2 times.
✓ Branch 1 taken 28900 times.
✓ Branch 2 taken 2 times.
✗ Branch 3 not taken.
|
28902 | if (pes->st->codecpar->codec_id == AV_CODEC_ID_NONE && !pes_sti->request_probe) { |
1219 | 2 | av_log(pes->stream, AV_LOG_TRACE, | |
1220 | "pid=%x stream_type=%x probing\n", | ||
1221 | pes->pid, | ||
1222 | pes->stream_type); | ||
1223 | 2 | pes_sti->request_probe = 1; | |
1224 | } | ||
1225 | } else { | ||
1226 | ✗ | pes->pes_header_size = 6; | |
1227 | ✗ | pes->state = MPEGTS_PAYLOAD; | |
1228 | ✗ | pes->data_index = 0; | |
1229 | } | ||
1230 | } else { | ||
1231 | /* otherwise, it should be a table */ | ||
1232 | /* skip packet */ | ||
1233 | 7 | skip: | |
1234 | 588 | pes->state = MPEGTS_SKIP; | |
1235 | 588 | continue; | |
1236 | } | ||
1237 | } | ||
1238 | 28904 | break; | |
1239 | /**********************************************/ | ||
1240 | /* PES packing parsing */ | ||
1241 | 28902 | case MPEGTS_PESHEADER: | |
1242 | 28902 | len = PES_HEADER_SIZE - pes->data_index; | |
1243 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 28902 times.
|
28902 | if (len < 0) |
1244 | ✗ | return AVERROR_INVALIDDATA; | |
1245 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 28902 times.
|
28902 | if (len > buf_size) |
1246 | ✗ | len = buf_size; | |
1247 | 28902 | memcpy(pes->header + pes->data_index, p, len); | |
1248 | 28902 | pes->data_index += len; | |
1249 | 28902 | p += len; | |
1250 | 28902 | buf_size -= len; | |
1251 |
1/2✓ Branch 0 taken 28902 times.
✗ Branch 1 not taken.
|
28902 | if (pes->data_index == PES_HEADER_SIZE) { |
1252 | 28902 | pes->pes_header_size = pes->header[8] + 9; | |
1253 | 28902 | pes->state = MPEGTS_PESHEADER_FILL; | |
1254 | } | ||
1255 | 28902 | break; | |
1256 | 28902 | case MPEGTS_PESHEADER_FILL: | |
1257 | 28902 | len = pes->pes_header_size - pes->data_index; | |
1258 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 28902 times.
|
28902 | if (len < 0) |
1259 | ✗ | return AVERROR_INVALIDDATA; | |
1260 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 28902 times.
|
28902 | if (len > buf_size) |
1261 | ✗ | len = buf_size; | |
1262 | 28902 | memcpy(pes->header + pes->data_index, p, len); | |
1263 | 28902 | pes->data_index += len; | |
1264 | 28902 | p += len; | |
1265 | 28902 | buf_size -= len; | |
1266 |
1/2✓ Branch 0 taken 28902 times.
✗ Branch 1 not taken.
|
28902 | if (pes->data_index == pes->pes_header_size) { |
1267 | const uint8_t *r; | ||
1268 | unsigned int flags, pes_ext, skip; | ||
1269 | |||
1270 | 28902 | flags = pes->header[7]; | |
1271 | 28902 | r = pes->header + 9; | |
1272 | 28902 | pes->pts = AV_NOPTS_VALUE; | |
1273 | 28902 | pes->dts = AV_NOPTS_VALUE; | |
1274 |
2/2✓ Branch 0 taken 10045 times.
✓ Branch 1 taken 18857 times.
|
28902 | if ((flags & 0xc0) == 0x80) { |
1275 | 10045 | pes->dts = pes->pts = ff_parse_pes_pts(r); | |
1276 | 10045 | r += 5; | |
1277 |
2/2✓ Branch 0 taken 1840 times.
✓ Branch 1 taken 17017 times.
|
18857 | } else if ((flags & 0xc0) == 0xc0) { |
1278 | 1840 | pes->pts = ff_parse_pes_pts(r); | |
1279 | 1840 | r += 5; | |
1280 | 1840 | pes->dts = ff_parse_pes_pts(r); | |
1281 | 1840 | r += 5; | |
1282 | } | ||
1283 | 28902 | pes->extended_stream_id = -1; | |
1284 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 28902 times.
|
28902 | if (flags & 0x01) { /* PES extension */ |
1285 | ✗ | pes_ext = *r++; | |
1286 | /* Skip PES private data, program packet sequence counter and P-STD buffer */ | ||
1287 | ✗ | skip = (pes_ext >> 4) & 0xb; | |
1288 | ✗ | skip += skip & 0x9; | |
1289 | ✗ | r += skip; | |
1290 | ✗ | if ((pes_ext & 0x41) == 0x01 && | |
1291 | ✗ | (r + 2) <= (pes->header + pes->pes_header_size)) { | |
1292 | /* PES extension 2 */ | ||
1293 | ✗ | if ((r[0] & 0x7f) > 0 && (r[1] & 0x80) == 0) | |
1294 | ✗ | pes->extended_stream_id = r[1]; | |
1295 | } | ||
1296 | } | ||
1297 | |||
1298 | /* we got the full header. We parse it and get the payload */ | ||
1299 | 28902 | pes->state = MPEGTS_PAYLOAD; | |
1300 | 28902 | pes->data_index = 0; | |
1301 |
1/4✗ Branch 0 not taken.
✓ Branch 1 taken 28902 times.
✗ Branch 2 not taken.
✗ Branch 3 not taken.
|
28902 | if (pes->stream_type == 0x12 && buf_size > 0) { |
1302 | ✗ | int sl_header_bytes = read_sl_header(pes, &pes->sl, p, | |
1303 | buf_size); | ||
1304 | ✗ | pes->pes_header_size += sl_header_bytes; | |
1305 | ✗ | p += sl_header_bytes; | |
1306 | ✗ | buf_size -= sl_header_bytes; | |
1307 | } | ||
1308 |
2/2✓ Branch 0 taken 6 times.
✓ Branch 1 taken 28896 times.
|
28902 | if (pes->stream_type == STREAM_TYPE_METADATA && |
1309 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 6 times.
|
6 | pes->stream_id == STREAM_ID_METADATA_STREAM && |
1310 | ✗ | pes->st->codecpar->codec_id == AV_CODEC_ID_SMPTE_KLV && | |
1311 | buf_size >= 5) { | ||
1312 | /* skip metadata access unit header - see MISB ST 1402 */ | ||
1313 | ✗ | pes->pes_header_size += 5; | |
1314 | ✗ | p += 5; | |
1315 | ✗ | buf_size -= 5; | |
1316 | } | ||
1317 |
1/2✓ Branch 0 taken 28902 times.
✗ Branch 1 not taken.
|
28902 | if ( pes->ts->fix_teletext_pts |
1318 |
1/2✓ Branch 0 taken 28902 times.
✗ Branch 1 not taken.
|
28902 | && ( pes->st->codecpar->codec_id == AV_CODEC_ID_DVB_TELETEXT |
1319 |
2/2✓ Branch 0 taken 254 times.
✓ Branch 1 taken 28648 times.
|
28902 | || pes->st->codecpar->codec_id == AV_CODEC_ID_DVB_SUBTITLE) |
1320 | ) { | ||
1321 | 254 | AVProgram *p = NULL; | |
1322 | 254 | int pcr_found = 0; | |
1323 |
2/2✓ Branch 1 taken 254 times.
✓ Branch 2 taken 254 times.
|
508 | while ((p = av_find_program_from_stream(pes->stream, p, pes->st->index))) { |
1324 |
2/4✓ Branch 0 taken 254 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 254 times.
✗ Branch 3 not taken.
|
254 | if (p->pcr_pid != -1 && p->discard != AVDISCARD_ALL) { |
1325 | 254 | MpegTSFilter *f = pes->ts->pids[p->pcr_pid]; | |
1326 |
1/2✓ Branch 0 taken 254 times.
✗ Branch 1 not taken.
|
254 | if (f) { |
1327 | 254 | AVStream *st = NULL; | |
1328 |
1/2✓ Branch 0 taken 254 times.
✗ Branch 1 not taken.
|
254 | if (f->type == MPEGTS_PES) { |
1329 | 254 | PESContext *pcrpes = f->u.pes_filter.opaque; | |
1330 |
1/2✓ Branch 0 taken 254 times.
✗ Branch 1 not taken.
|
254 | if (pcrpes) |
1331 | 254 | st = pcrpes->st; | |
1332 | ✗ | } else if (f->type == MPEGTS_PCR) { | |
1333 | int i; | ||
1334 | ✗ | for (i = 0; i < p->nb_stream_indexes; i++) { | |
1335 | ✗ | AVStream *pst = pes->stream->streams[p->stream_index[i]]; | |
1336 | ✗ | if (pst->codecpar->codec_type == AVMEDIA_TYPE_VIDEO) | |
1337 | ✗ | st = pst; | |
1338 | } | ||
1339 | } | ||
1340 |
1/4✗ Branch 0 not taken.
✓ Branch 1 taken 254 times.
✗ Branch 2 not taken.
✗ Branch 3 not taken.
|
254 | if (f->last_pcr != -1 && !f->discard) { |
1341 | // teletext packets do not always have correct timestamps, | ||
1342 | // the standard says they should be handled after 40.6 ms at most, | ||
1343 | // and the pcr error to this packet should be no more than 100 ms. | ||
1344 | // TODO: we should interpolate the PCR, not just use the last one | ||
1345 | ✗ | int64_t pcr = f->last_pcr / 300; | |
1346 | ✗ | pcr_found = 1; | |
1347 | ✗ | if (st) { | |
1348 | ✗ | const FFStream *const sti = ffstream(st); | |
1349 | ✗ | FFStream *const pes_sti = ffstream(pes->st); | |
1350 | |||
1351 | ✗ | pes_sti->pts_wrap_reference = sti->pts_wrap_reference; | |
1352 | ✗ | pes_sti->pts_wrap_behavior = sti->pts_wrap_behavior; | |
1353 | } | ||
1354 | ✗ | if (pes->dts == AV_NOPTS_VALUE || pes->dts < pcr) { | |
1355 | ✗ | pes->pts = pes->dts = pcr; | |
1356 | ✗ | } else if (pes->st->codecpar->codec_id == AV_CODEC_ID_DVB_TELETEXT && | |
1357 | ✗ | pes->dts > pcr + 3654 + 9000) { | |
1358 | ✗ | pes->pts = pes->dts = pcr + 3654 + 9000; | |
1359 | ✗ | } else if (pes->st->codecpar->codec_id == AV_CODEC_ID_DVB_SUBTITLE && | |
1360 | ✗ | pes->dts > pcr + 10*90000) { //10sec | |
1361 | ✗ | pes->pts = pes->dts = pcr + 3654 + 9000; | |
1362 | } | ||
1363 | ✗ | break; | |
1364 | } | ||
1365 | } | ||
1366 | } | ||
1367 | } | ||
1368 | |||
1369 |
1/4✗ Branch 0 not taken.
✓ Branch 1 taken 254 times.
✗ Branch 2 not taken.
✗ Branch 3 not taken.
|
254 | if (pes->st->codecpar->codec_id == AV_CODEC_ID_DVB_TELETEXT && |
1370 | !pcr_found) { | ||
1371 | ✗ | av_log(pes->stream, AV_LOG_VERBOSE, | |
1372 | "Forcing DTS/PTS to be unset for a " | ||
1373 | "non-trustworthy PES packet for PID %d as " | ||
1374 | "PCR hasn't been received yet.\n", | ||
1375 | pes->pid); | ||
1376 | ✗ | pes->dts = pes->pts = AV_NOPTS_VALUE; | |
1377 | } | ||
1378 | } | ||
1379 | } | ||
1380 | 28902 | break; | |
1381 | 350837 | case MPEGTS_PAYLOAD: | |
1382 | do { | ||
1383 | 350837 | int max_packet_size = ts->max_packet_size; | |
1384 |
3/4✓ Branch 0 taken 194777 times.
✓ Branch 1 taken 156060 times.
✓ Branch 2 taken 194777 times.
✗ Branch 3 not taken.
|
350837 | if (pes->PES_packet_length && pes->PES_packet_length + PES_START_SIZE > pes->pes_header_size) |
1385 | 194777 | max_packet_size = pes->PES_packet_length + PES_START_SIZE - pes->pes_header_size; | |
1386 | |||
1387 |
2/2✓ Branch 0 taken 321935 times.
✓ Branch 1 taken 28902 times.
|
350837 | if (pes->data_index > 0 && |
1388 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 321935 times.
|
321935 | pes->data_index + buf_size > max_packet_size) { |
1389 | ✗ | ret = new_pes_packet(pes, ts->pkt); | |
1390 | ✗ | if (ret < 0) | |
1391 | ✗ | return ret; | |
1392 | ✗ | pes->PES_packet_length = 0; | |
1393 | ✗ | max_packet_size = ts->max_packet_size; | |
1394 | ✗ | ts->stop_parse = 1; | |
1395 |
3/4✓ Branch 0 taken 28902 times.
✓ Branch 1 taken 321935 times.
✗ Branch 2 not taken.
✓ Branch 3 taken 28902 times.
|
350837 | } else if (pes->data_index == 0 && |
1396 | buf_size > max_packet_size) { | ||
1397 | // pes packet size is < ts size packet and pes data is padded with 0xff | ||
1398 | // not sure if this is legal in ts but see issue #2392 | ||
1399 | ✗ | buf_size = max_packet_size; | |
1400 | } | ||
1401 | |||
1402 |
2/2✓ Branch 0 taken 28902 times.
✓ Branch 1 taken 321935 times.
|
350837 | if (!pes->buffer) { |
1403 | 28902 | pes->buffer = buffer_pool_get(ts, max_packet_size); | |
1404 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 28902 times.
|
28902 | if (!pes->buffer) |
1405 | ✗ | return AVERROR(ENOMEM); | |
1406 | } | ||
1407 | |||
1408 | 350837 | memcpy(pes->buffer->data + pes->data_index, p, buf_size); | |
1409 | 350837 | pes->data_index += buf_size; | |
1410 | /* emit complete packets with known packet size | ||
1411 | * decreases demuxer delay for infrequent packets like subtitles from | ||
1412 | * a couple of seconds to milliseconds for properly muxed files. */ | ||
1413 |
4/4✓ Branch 0 taken 347999 times.
✓ Branch 1 taken 2838 times.
✓ Branch 2 taken 194777 times.
✓ Branch 3 taken 153222 times.
|
350837 | if (!ts->stop_parse && pes->PES_packet_length && |
1414 |
2/2✓ Branch 0 taken 25817 times.
✓ Branch 1 taken 168960 times.
|
194777 | pes->pes_header_size + pes->data_index == pes->PES_packet_length + PES_START_SIZE) { |
1415 | 25817 | ts->stop_parse = 1; | |
1416 | 25817 | ret = new_pes_packet(pes, ts->pkt); | |
1417 | 25817 | pes->state = MPEGTS_SKIP; | |
1418 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 25817 times.
|
25817 | if (ret < 0) |
1419 | ✗ | return ret; | |
1420 | } | ||
1421 | } while (0); | ||
1422 | 350837 | buf_size = 0; | |
1423 | 350837 | break; | |
1424 | 15802 | case MPEGTS_SKIP: | |
1425 | 15802 | buf_size = 0; | |
1426 | 15802 | break; | |
1427 | } | ||
1428 | } | ||
1429 | |||
1430 | 366641 | return 0; | |
1431 | } | ||
1432 | |||
1433 | 118 | static PESContext *add_pes_stream(MpegTSContext *ts, int pid, int pcr_pid) | |
1434 | { | ||
1435 | MpegTSFilter *tss; | ||
1436 | PESContext *pes; | ||
1437 | |||
1438 | /* if no pid found, then add a pid context */ | ||
1439 | 118 | pes = av_mallocz(sizeof(PESContext)); | |
1440 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 118 times.
|
118 | if (!pes) |
1441 | ✗ | return 0; | |
1442 | 118 | pes->ts = ts; | |
1443 | 118 | pes->stream = ts->stream; | |
1444 | 118 | pes->pid = pid; | |
1445 | 118 | pes->pcr_pid = pcr_pid; | |
1446 | 118 | pes->state = MPEGTS_SKIP; | |
1447 | 118 | pes->pts = AV_NOPTS_VALUE; | |
1448 | 118 | pes->dts = AV_NOPTS_VALUE; | |
1449 | 118 | tss = mpegts_open_pes_filter(ts, pid, mpegts_push_data, pes); | |
1450 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 118 times.
|
118 | if (!tss) { |
1451 | ✗ | av_free(pes); | |
1452 | ✗ | return 0; | |
1453 | } | ||
1454 | 118 | return pes; | |
1455 | } | ||
1456 | |||
1457 | #define MAX_LEVEL 4 | ||
1458 | typedef struct MP4DescrParseContext { | ||
1459 | AVFormatContext *s; | ||
1460 | FFIOContext pb; | ||
1461 | Mp4Descr *descr; | ||
1462 | Mp4Descr *active_descr; | ||
1463 | int descr_count; | ||
1464 | int max_descr_count; | ||
1465 | int level; | ||
1466 | int predefined_SLConfigDescriptor_seen; | ||
1467 | } MP4DescrParseContext; | ||
1468 | |||
1469 | ✗ | static int init_MP4DescrParseContext(MP4DescrParseContext *d, AVFormatContext *s, | |
1470 | const uint8_t *buf, unsigned size, | ||
1471 | Mp4Descr *descr, int max_descr_count) | ||
1472 | { | ||
1473 | ✗ | if (size > (1 << 30)) | |
1474 | ✗ | return AVERROR_INVALIDDATA; | |
1475 | |||
1476 | ✗ | ffio_init_read_context(&d->pb, buf, size); | |
1477 | |||
1478 | ✗ | d->s = s; | |
1479 | ✗ | d->level = 0; | |
1480 | ✗ | d->descr_count = 0; | |
1481 | ✗ | d->descr = descr; | |
1482 | ✗ | d->active_descr = NULL; | |
1483 | ✗ | d->max_descr_count = max_descr_count; | |
1484 | |||
1485 | ✗ | return 0; | |
1486 | } | ||
1487 | |||
1488 | ✗ | static void update_offsets(AVIOContext *pb, int64_t *off, int *len) | |
1489 | { | ||
1490 | ✗ | int64_t new_off = avio_tell(pb); | |
1491 | ✗ | (*len) -= new_off - *off; | |
1492 | ✗ | *off = new_off; | |
1493 | ✗ | } | |
1494 | |||
1495 | static int parse_mp4_descr(MP4DescrParseContext *d, int64_t off, int len, | ||
1496 | int target_tag); | ||
1497 | |||
1498 | ✗ | static int parse_mp4_descr_arr(MP4DescrParseContext *d, int64_t off, int len) | |
1499 | { | ||
1500 | ✗ | while (len > 0) { | |
1501 | ✗ | int ret = parse_mp4_descr(d, off, len, 0); | |
1502 | ✗ | if (ret < 0) | |
1503 | ✗ | return ret; | |
1504 | ✗ | update_offsets(&d->pb.pub, &off, &len); | |
1505 | } | ||
1506 | ✗ | return 0; | |
1507 | } | ||
1508 | |||
1509 | ✗ | static int parse_MP4IODescrTag(MP4DescrParseContext *d, int64_t off, int len) | |
1510 | { | ||
1511 | ✗ | AVIOContext *const pb = &d->pb.pub; | |
1512 | ✗ | avio_rb16(pb); // ID | |
1513 | ✗ | avio_r8(pb); | |
1514 | ✗ | avio_r8(pb); | |
1515 | ✗ | avio_r8(pb); | |
1516 | ✗ | avio_r8(pb); | |
1517 | ✗ | avio_r8(pb); | |
1518 | ✗ | update_offsets(pb, &off, &len); | |
1519 | ✗ | return parse_mp4_descr_arr(d, off, len); | |
1520 | } | ||
1521 | |||
1522 | ✗ | static int parse_MP4ODescrTag(MP4DescrParseContext *d, int64_t off, int len) | |
1523 | { | ||
1524 | int id_flags; | ||
1525 | ✗ | if (len < 2) | |
1526 | ✗ | return 0; | |
1527 | ✗ | id_flags = avio_rb16(&d->pb.pub); | |
1528 | ✗ | if (!(id_flags & 0x0020)) { // URL_Flag | |
1529 | ✗ | update_offsets(&d->pb.pub, &off, &len); | |
1530 | ✗ | return parse_mp4_descr_arr(d, off, len); // ES_Descriptor[] | |
1531 | } else { | ||
1532 | ✗ | return 0; | |
1533 | } | ||
1534 | } | ||
1535 | |||
1536 | ✗ | static int parse_MP4ESDescrTag(MP4DescrParseContext *d, int64_t off, int len) | |
1537 | { | ||
1538 | ✗ | AVIOContext *const pb = &d->pb.pub; | |
1539 | ✗ | int es_id = 0; | |
1540 | ✗ | int ret = 0; | |
1541 | |||
1542 | ✗ | if (d->descr_count >= d->max_descr_count) | |
1543 | ✗ | return AVERROR_INVALIDDATA; | |
1544 | ✗ | ff_mp4_parse_es_descr(pb, &es_id); | |
1545 | ✗ | d->active_descr = d->descr + (d->descr_count++); | |
1546 | |||
1547 | ✗ | d->active_descr->es_id = es_id; | |
1548 | ✗ | update_offsets(pb, &off, &len); | |
1549 | ✗ | if ((ret = parse_mp4_descr(d, off, len, MP4DecConfigDescrTag)) < 0) | |
1550 | ✗ | return ret; | |
1551 | ✗ | update_offsets(pb, &off, &len); | |
1552 | ✗ | if (len > 0) | |
1553 | ✗ | ret = parse_mp4_descr(d, off, len, MP4SLDescrTag); | |
1554 | ✗ | d->active_descr = NULL; | |
1555 | ✗ | return ret; | |
1556 | } | ||
1557 | |||
1558 | ✗ | static int parse_MP4DecConfigDescrTag(MP4DescrParseContext *d, int64_t off, | |
1559 | int len) | ||
1560 | { | ||
1561 | ✗ | Mp4Descr *descr = d->active_descr; | |
1562 | ✗ | if (!descr) | |
1563 | ✗ | return AVERROR_INVALIDDATA; | |
1564 | ✗ | d->active_descr->dec_config_descr = av_malloc(len); | |
1565 | ✗ | if (!descr->dec_config_descr) | |
1566 | ✗ | return AVERROR(ENOMEM); | |
1567 | ✗ | descr->dec_config_descr_len = len; | |
1568 | ✗ | avio_read(&d->pb.pub, descr->dec_config_descr, len); | |
1569 | ✗ | return 0; | |
1570 | } | ||
1571 | |||
1572 | ✗ | static int parse_MP4SLDescrTag(MP4DescrParseContext *d, int64_t off, int len) | |
1573 | { | ||
1574 | ✗ | Mp4Descr *descr = d->active_descr; | |
1575 | ✗ | AVIOContext *const pb = &d->pb.pub; | |
1576 | int predefined; | ||
1577 | ✗ | if (!descr) | |
1578 | ✗ | return AVERROR_INVALIDDATA; | |
1579 | |||
1580 | #define R8_CHECK_CLIP_MAX(dst, maxv) do { \ | ||
1581 | descr->sl.dst = avio_r8(pb); \ | ||
1582 | if (descr->sl.dst > maxv) { \ | ||
1583 | descr->sl.dst = maxv; \ | ||
1584 | return AVERROR_INVALIDDATA; \ | ||
1585 | } \ | ||
1586 | } while (0) | ||
1587 | |||
1588 | ✗ | predefined = avio_r8(pb); | |
1589 | ✗ | if (!predefined) { | |
1590 | int lengths; | ||
1591 | ✗ | int flags = avio_r8(pb); | |
1592 | ✗ | descr->sl.use_au_start = !!(flags & 0x80); | |
1593 | ✗ | descr->sl.use_au_end = !!(flags & 0x40); | |
1594 | ✗ | descr->sl.use_rand_acc_pt = !!(flags & 0x20); | |
1595 | ✗ | descr->sl.use_padding = !!(flags & 0x08); | |
1596 | ✗ | descr->sl.use_timestamps = !!(flags & 0x04); | |
1597 | ✗ | descr->sl.use_idle = !!(flags & 0x02); | |
1598 | ✗ | descr->sl.timestamp_res = avio_rb32(pb); | |
1599 | ✗ | avio_rb32(pb); | |
1600 | ✗ | R8_CHECK_CLIP_MAX(timestamp_len, 63); | |
1601 | ✗ | R8_CHECK_CLIP_MAX(ocr_len, 63); | |
1602 | ✗ | R8_CHECK_CLIP_MAX(au_len, 31); | |
1603 | ✗ | descr->sl.inst_bitrate_len = avio_r8(pb); | |
1604 | ✗ | lengths = avio_rb16(pb); | |
1605 | ✗ | descr->sl.degr_prior_len = lengths >> 12; | |
1606 | ✗ | descr->sl.au_seq_num_len = (lengths >> 7) & 0x1f; | |
1607 | ✗ | descr->sl.packet_seq_num_len = (lengths >> 2) & 0x1f; | |
1608 | ✗ | } else if (!d->predefined_SLConfigDescriptor_seen){ | |
1609 | ✗ | avpriv_report_missing_feature(d->s, "Predefined SLConfigDescriptor"); | |
1610 | ✗ | d->predefined_SLConfigDescriptor_seen = 1; | |
1611 | } | ||
1612 | ✗ | return 0; | |
1613 | } | ||
1614 | |||
1615 | ✗ | static int parse_mp4_descr(MP4DescrParseContext *d, int64_t off, int len, | |
1616 | int target_tag) | ||
1617 | { | ||
1618 | int tag; | ||
1619 | ✗ | AVIOContext *const pb = &d->pb.pub; | |
1620 | ✗ | int len1 = ff_mp4_read_descr(d->s, pb, &tag); | |
1621 | ✗ | int ret = 0; | |
1622 | |||
1623 | ✗ | update_offsets(pb, &off, &len); | |
1624 | ✗ | if (len < 0 || len1 > len || len1 <= 0) { | |
1625 | ✗ | av_log(d->s, AV_LOG_ERROR, | |
1626 | "Tag %x length violation new length %d bytes remaining %d\n", | ||
1627 | tag, len1, len); | ||
1628 | ✗ | return AVERROR_INVALIDDATA; | |
1629 | } | ||
1630 | |||
1631 | ✗ | if (d->level++ >= MAX_LEVEL) { | |
1632 | ✗ | av_log(d->s, AV_LOG_ERROR, "Maximum MP4 descriptor level exceeded\n"); | |
1633 | ✗ | ret = AVERROR_INVALIDDATA; | |
1634 | ✗ | goto done; | |
1635 | } | ||
1636 | |||
1637 | ✗ | if (target_tag && tag != target_tag) { | |
1638 | ✗ | av_log(d->s, AV_LOG_ERROR, "Found tag %x expected %x\n", tag, | |
1639 | target_tag); | ||
1640 | ✗ | ret = AVERROR_INVALIDDATA; | |
1641 | ✗ | goto done; | |
1642 | } | ||
1643 | |||
1644 | ✗ | switch (tag) { | |
1645 | ✗ | case MP4IODescrTag: | |
1646 | ✗ | ret = parse_MP4IODescrTag(d, off, len1); | |
1647 | ✗ | break; | |
1648 | ✗ | case MP4ODescrTag: | |
1649 | ✗ | ret = parse_MP4ODescrTag(d, off, len1); | |
1650 | ✗ | break; | |
1651 | ✗ | case MP4ESDescrTag: | |
1652 | ✗ | ret = parse_MP4ESDescrTag(d, off, len1); | |
1653 | ✗ | break; | |
1654 | ✗ | case MP4DecConfigDescrTag: | |
1655 | ✗ | ret = parse_MP4DecConfigDescrTag(d, off, len1); | |
1656 | ✗ | break; | |
1657 | ✗ | case MP4SLDescrTag: | |
1658 | ✗ | ret = parse_MP4SLDescrTag(d, off, len1); | |
1659 | ✗ | break; | |
1660 | } | ||
1661 | |||
1662 | |||
1663 | ✗ | done: | |
1664 | ✗ | d->level--; | |
1665 | ✗ | avio_seek(pb, off + len1, SEEK_SET); | |
1666 | ✗ | return ret; | |
1667 | } | ||
1668 | |||
1669 | ✗ | static int mp4_read_iods(AVFormatContext *s, const uint8_t *buf, unsigned size, | |
1670 | Mp4Descr *descr, int *descr_count, int max_descr_count) | ||
1671 | { | ||
1672 | MP4DescrParseContext d; | ||
1673 | int ret; | ||
1674 | |||
1675 | ✗ | ret = init_MP4DescrParseContext(&d, s, buf, size, descr, max_descr_count); | |
1676 | ✗ | if (ret < 0) | |
1677 | ✗ | return ret; | |
1678 | |||
1679 | ✗ | ret = parse_mp4_descr(&d, avio_tell(&d.pb.pub), size, MP4IODescrTag); | |
1680 | |||
1681 | ✗ | *descr_count = d.descr_count; | |
1682 | ✗ | return ret; | |
1683 | } | ||
1684 | |||
1685 | ✗ | static int mp4_read_od(AVFormatContext *s, const uint8_t *buf, unsigned size, | |
1686 | Mp4Descr *descr, int *descr_count, int max_descr_count) | ||
1687 | { | ||
1688 | MP4DescrParseContext d; | ||
1689 | int ret; | ||
1690 | |||
1691 | ✗ | ret = init_MP4DescrParseContext(&d, s, buf, size, descr, max_descr_count); | |
1692 | ✗ | if (ret < 0) | |
1693 | ✗ | return ret; | |
1694 | |||
1695 | ✗ | ret = parse_mp4_descr_arr(&d, avio_tell(&d.pb.pub), size); | |
1696 | |||
1697 | ✗ | *descr_count = d.descr_count; | |
1698 | ✗ | return ret; | |
1699 | } | ||
1700 | |||
1701 | ✗ | static void m4sl_cb(MpegTSFilter *filter, const uint8_t *section, | |
1702 | int section_len) | ||
1703 | { | ||
1704 | ✗ | MpegTSContext *ts = filter->u.section_filter.opaque; | |
1705 | ✗ | MpegTSSectionFilter *tssf = &filter->u.section_filter; | |
1706 | SectionHeader h; | ||
1707 | const uint8_t *p, *p_end; | ||
1708 | ✗ | int mp4_descr_count = 0; | |
1709 | ✗ | Mp4Descr mp4_descr[MAX_MP4_DESCR_COUNT] = { { 0 } }; | |
1710 | int i, pid; | ||
1711 | ✗ | AVFormatContext *s = ts->stream; | |
1712 | |||
1713 | ✗ | p_end = section + section_len - 4; | |
1714 | ✗ | p = section; | |
1715 | ✗ | if (parse_section_header(&h, &p, p_end) < 0) | |
1716 | ✗ | return; | |
1717 | ✗ | if (h.tid != M4OD_TID) | |
1718 | ✗ | return; | |
1719 | ✗ | if (skip_identical(&h, tssf)) | |
1720 | ✗ | return; | |
1721 | |||
1722 | ✗ | mp4_read_od(s, p, (unsigned) (p_end - p), mp4_descr, &mp4_descr_count, | |
1723 | MAX_MP4_DESCR_COUNT); | ||
1724 | |||
1725 | ✗ | for (pid = 0; pid < NB_PID_MAX; pid++) { | |
1726 | ✗ | if (!ts->pids[pid]) | |
1727 | ✗ | continue; | |
1728 | ✗ | for (i = 0; i < mp4_descr_count; i++) { | |
1729 | PESContext *pes; | ||
1730 | AVStream *st; | ||
1731 | FFStream *sti; | ||
1732 | FFIOContext pb; | ||
1733 | ✗ | if (ts->pids[pid]->es_id != mp4_descr[i].es_id) | |
1734 | ✗ | continue; | |
1735 | ✗ | if (ts->pids[pid]->type != MPEGTS_PES) { | |
1736 | ✗ | av_log(s, AV_LOG_ERROR, "pid %x is not PES\n", pid); | |
1737 | ✗ | continue; | |
1738 | } | ||
1739 | ✗ | pes = ts->pids[pid]->u.pes_filter.opaque; | |
1740 | ✗ | st = pes->st; | |
1741 | ✗ | if (!st) | |
1742 | ✗ | continue; | |
1743 | ✗ | sti = ffstream(st); | |
1744 | |||
1745 | ✗ | pes->sl = mp4_descr[i].sl; | |
1746 | |||
1747 | ✗ | ffio_init_read_context(&pb, mp4_descr[i].dec_config_descr, | |
1748 | mp4_descr[i].dec_config_descr_len); | ||
1749 | ✗ | ff_mp4_read_dec_config_descr(s, st, &pb.pub); | |
1750 | ✗ | if (st->codecpar->codec_id == AV_CODEC_ID_AAC && | |
1751 | ✗ | st->codecpar->extradata_size > 0) | |
1752 | ✗ | sti->need_parsing = 0; | |
1753 | ✗ | if (st->codecpar->codec_id == AV_CODEC_ID_H264 && | |
1754 | ✗ | st->codecpar->extradata_size > 0) | |
1755 | ✗ | sti->need_parsing = 0; | |
1756 | |||
1757 | ✗ | st->codecpar->codec_type = avcodec_get_type(st->codecpar->codec_id); | |
1758 | ✗ | sti->need_context_update = 1; | |
1759 | } | ||
1760 | } | ||
1761 | ✗ | for (i = 0; i < mp4_descr_count; i++) | |
1762 | ✗ | av_free(mp4_descr[i].dec_config_descr); | |
1763 | } | ||
1764 | |||
1765 | ✗ | static void scte_data_cb(MpegTSFilter *filter, const uint8_t *section, | |
1766 | int section_len) | ||
1767 | { | ||
1768 | ✗ | AVProgram *prg = NULL; | |
1769 | ✗ | MpegTSContext *ts = filter->u.section_filter.opaque; | |
1770 | |||
1771 | ✗ | int idx = ff_find_stream_index(ts->stream, filter->pid); | |
1772 | ✗ | if (idx < 0) | |
1773 | ✗ | return; | |
1774 | |||
1775 | /** | ||
1776 | * In case we receive an SCTE-35 packet before mpegts context is fully | ||
1777 | * initialized. | ||
1778 | */ | ||
1779 | ✗ | if (!ts->pkt) | |
1780 | ✗ | return; | |
1781 | |||
1782 | ✗ | new_data_packet(section, section_len, ts->pkt); | |
1783 | ✗ | ts->pkt->stream_index = idx; | |
1784 | ✗ | prg = av_find_program_from_stream(ts->stream, NULL, idx); | |
1785 | ✗ | if (prg && prg->pcr_pid != -1 && prg->discard != AVDISCARD_ALL) { | |
1786 | ✗ | MpegTSFilter *f = ts->pids[prg->pcr_pid]; | |
1787 | ✗ | if (f && f->last_pcr != -1) | |
1788 | ✗ | ts->pkt->pts = ts->pkt->dts = f->last_pcr/300; | |
1789 | } | ||
1790 | ✗ | ts->stop_parse = 1; | |
1791 | |||
1792 | } | ||
1793 | |||
1794 | static const uint8_t opus_coupled_stream_cnt[9] = { | ||
1795 | 1, 0, 1, 1, 2, 2, 2, 3, 3 | ||
1796 | }; | ||
1797 | |||
1798 | static const uint8_t opus_stream_cnt[9] = { | ||
1799 | 1, 1, 1, 2, 2, 3, 4, 4, 5, | ||
1800 | }; | ||
1801 | |||
1802 | static const uint8_t opus_channel_map[8][8] = { | ||
1803 | { 0 }, | ||
1804 | { 0,1 }, | ||
1805 | { 0,2,1 }, | ||
1806 | { 0,1,2,3 }, | ||
1807 | { 0,4,1,2,3 }, | ||
1808 | { 0,4,1,2,3,5 }, | ||
1809 | { 0,4,1,2,3,5,6 }, | ||
1810 | { 0,6,1,2,3,4,5,7 }, | ||
1811 | }; | ||
1812 | |||
1813 | 845 | int ff_parse_mpeg2_descriptor(AVFormatContext *fc, AVStream *st, int stream_type, | |
1814 | const uint8_t **pp, const uint8_t *desc_list_end, | ||
1815 | Mp4Descr *mp4_descr, int mp4_descr_count, int pid, | ||
1816 | MpegTSContext *ts) | ||
1817 | { | ||
1818 | 845 | FFStream *const sti = ffstream(st); | |
1819 | const uint8_t *desc_end; | ||
1820 | int desc_len, desc_tag, desc_es_id, ext_desc_tag, channels, channel_config_code; | ||
1821 | char language[252]; | ||
1822 | int i; | ||
1823 | |||
1824 | 845 | desc_tag = get8(pp, desc_list_end); | |
1825 |
2/2✓ Branch 0 taken 519 times.
✓ Branch 1 taken 326 times.
|
845 | if (desc_tag < 0) |
1826 | 519 | return AVERROR_INVALIDDATA; | |
1827 | 326 | desc_len = get8(pp, desc_list_end); | |
1828 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 326 times.
|
326 | if (desc_len < 0) |
1829 | ✗ | return AVERROR_INVALIDDATA; | |
1830 | 326 | desc_end = *pp + desc_len; | |
1831 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 326 times.
|
326 | if (desc_end > desc_list_end) |
1832 | ✗ | return AVERROR_INVALIDDATA; | |
1833 | |||
1834 | 326 | av_log(fc, AV_LOG_TRACE, "tag: 0x%02x len=%d\n", desc_tag, desc_len); | |
1835 | |||
1836 |
6/6✓ Branch 0 taken 321 times.
✓ Branch 1 taken 5 times.
✓ Branch 2 taken 25 times.
✓ Branch 3 taken 296 times.
✓ Branch 4 taken 12 times.
✓ Branch 5 taken 18 times.
|
326 | if ((st->codecpar->codec_id == AV_CODEC_ID_NONE || sti->request_probe > 0) && |
1837 | stream_type == STREAM_TYPE_PRIVATE_DATA) | ||
1838 | 12 | mpegts_find_stream_type(st, desc_tag, DESC_types); | |
1839 | |||
1840 |
8/15✗ Branch 0 not taken.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✗ Branch 3 not taken.
✓ Branch 4 taken 9 times.
✓ Branch 5 taken 204 times.
✓ Branch 6 taken 8 times.
✓ Branch 7 taken 31 times.
✓ Branch 8 taken 4 times.
✓ Branch 9 taken 4 times.
✓ Branch 10 taken 6 times.
✗ Branch 11 not taken.
✗ Branch 12 not taken.
✗ Branch 13 not taken.
✓ Branch 14 taken 60 times.
|
326 | switch (desc_tag) { |
1841 | ✗ | case VIDEO_STREAM_DESCRIPTOR: | |
1842 | ✗ | if (get8(pp, desc_end) & 0x1) { | |
1843 | ✗ | st->disposition |= AV_DISPOSITION_STILL_IMAGE; | |
1844 | } | ||
1845 | ✗ | break; | |
1846 | ✗ | case SL_DESCRIPTOR: | |
1847 | ✗ | desc_es_id = get16(pp, desc_end); | |
1848 | ✗ | if (desc_es_id < 0) | |
1849 | ✗ | break; | |
1850 | ✗ | if (ts && ts->pids[pid]) | |
1851 | ✗ | ts->pids[pid]->es_id = desc_es_id; | |
1852 | ✗ | for (i = 0; i < mp4_descr_count; i++) | |
1853 | ✗ | if (mp4_descr[i].dec_config_descr_len && | |
1854 | ✗ | mp4_descr[i].es_id == desc_es_id) { | |
1855 | FFIOContext pb; | ||
1856 | ✗ | ffio_init_read_context(&pb, mp4_descr[i].dec_config_descr, | |
1857 | ✗ | mp4_descr[i].dec_config_descr_len); | |
1858 | ✗ | ff_mp4_read_dec_config_descr(fc, st, &pb.pub); | |
1859 | ✗ | if (st->codecpar->codec_id == AV_CODEC_ID_AAC && | |
1860 | ✗ | st->codecpar->extradata_size > 0) { | |
1861 | ✗ | sti->need_parsing = 0; | |
1862 | ✗ | sti->need_context_update = 1; | |
1863 | } | ||
1864 | ✗ | if (st->codecpar->codec_id == AV_CODEC_ID_MPEG4SYSTEMS) | |
1865 | ✗ | mpegts_open_section_filter(ts, pid, m4sl_cb, ts, 1); | |
1866 | } | ||
1867 | ✗ | break; | |
1868 | ✗ | case FMC_DESCRIPTOR: | |
1869 | ✗ | if (get16(pp, desc_end) < 0) | |
1870 | ✗ | break; | |
1871 | ✗ | if (mp4_descr_count > 0 && | |
1872 | ✗ | (st->codecpar->codec_id == AV_CODEC_ID_AAC_LATM || | |
1873 | ✗ | (sti->request_probe == 0 && st->codecpar->codec_id == AV_CODEC_ID_NONE) || | |
1874 | ✗ | sti->request_probe > 0) && | |
1875 | ✗ | mp4_descr->dec_config_descr_len && mp4_descr->es_id == pid) { | |
1876 | FFIOContext pb; | ||
1877 | ✗ | ffio_init_read_context(&pb, mp4_descr->dec_config_descr, | |
1878 | mp4_descr->dec_config_descr_len); | ||
1879 | ✗ | ff_mp4_read_dec_config_descr(fc, st, &pb.pub); | |
1880 | ✗ | if (st->codecpar->codec_id == AV_CODEC_ID_AAC && | |
1881 | ✗ | st->codecpar->extradata_size > 0) { | |
1882 | ✗ | sti->request_probe = sti->need_parsing = 0; | |
1883 | ✗ | st->codecpar->codec_type = AVMEDIA_TYPE_AUDIO; | |
1884 | ✗ | sti->need_context_update = 1; | |
1885 | } | ||
1886 | } | ||
1887 | ✗ | break; | |
1888 | ✗ | case 0x56: /* DVB teletext descriptor */ | |
1889 | { | ||
1890 | ✗ | uint8_t *extradata = NULL; | |
1891 | ✗ | int language_count = desc_len / 5, ret; | |
1892 | |||
1893 | ✗ | if (desc_len > 0 && desc_len % 5 != 0) | |
1894 | ✗ | return AVERROR_INVALIDDATA; | |
1895 | |||
1896 | ✗ | if (language_count > 0) { | |
1897 | /* 4 bytes per language code (3 bytes) with comma or NUL byte should fit language buffer */ | ||
1898 | ✗ | av_assert0(language_count <= sizeof(language) / 4); | |
1899 | |||
1900 | ✗ | if (st->codecpar->extradata == NULL) { | |
1901 | ✗ | ret = ff_alloc_extradata(st->codecpar, language_count * 2); | |
1902 | ✗ | if (ret < 0) | |
1903 | ✗ | return ret; | |
1904 | } | ||
1905 | |||
1906 | ✗ | if (st->codecpar->extradata_size < language_count * 2) | |
1907 | ✗ | return AVERROR_INVALIDDATA; | |
1908 | |||
1909 | ✗ | extradata = st->codecpar->extradata; | |
1910 | |||
1911 | ✗ | for (i = 0; i < language_count; i++) { | |
1912 | ✗ | language[i * 4 + 0] = get8(pp, desc_end); | |
1913 | ✗ | language[i * 4 + 1] = get8(pp, desc_end); | |
1914 | ✗ | language[i * 4 + 2] = get8(pp, desc_end); | |
1915 | ✗ | language[i * 4 + 3] = ','; | |
1916 | |||
1917 | ✗ | memcpy(extradata, *pp, 2); | |
1918 | ✗ | extradata += 2; | |
1919 | |||
1920 | ✗ | *pp += 2; | |
1921 | } | ||
1922 | |||
1923 | ✗ | language[i * 4 - 1] = 0; | |
1924 | ✗ | av_dict_set(&st->metadata, "language", language, 0); | |
1925 | ✗ | sti->need_context_update = 1; | |
1926 | } | ||
1927 | } | ||
1928 | ✗ | break; | |
1929 | 9 | case 0x59: /* subtitling descriptor */ | |
1930 | { | ||
1931 | /* 8 bytes per DVB subtitle substream data: | ||
1932 | * ISO_639_language_code (3 bytes), | ||
1933 | * subtitling_type (1 byte), | ||
1934 | * composition_page_id (2 bytes), | ||
1935 | * ancillary_page_id (2 bytes) */ | ||
1936 | 9 | int language_count = desc_len / 8, ret; | |
1937 | |||
1938 |
2/4✓ Branch 0 taken 9 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 9 times.
|
9 | if (desc_len > 0 && desc_len % 8 != 0) |
1939 | ✗ | return AVERROR_INVALIDDATA; | |
1940 | |||
1941 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 9 times.
|
9 | if (language_count > 1) { |
1942 | ✗ | avpriv_request_sample(fc, "DVB subtitles with multiple languages"); | |
1943 | } | ||
1944 | |||
1945 |
1/2✓ Branch 0 taken 9 times.
✗ Branch 1 not taken.
|
9 | if (language_count > 0) { |
1946 | uint8_t *extradata; | ||
1947 | |||
1948 | /* 4 bytes per language code (3 bytes) with comma or NUL byte should fit language buffer */ | ||
1949 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 9 times.
|
9 | av_assert0(language_count <= sizeof(language) / 4); |
1950 | |||
1951 |
2/2✓ Branch 0 taken 3 times.
✓ Branch 1 taken 6 times.
|
9 | if (st->codecpar->extradata == NULL) { |
1952 | 3 | ret = ff_alloc_extradata(st->codecpar, language_count * 5); | |
1953 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 3 times.
|
3 | if (ret < 0) |
1954 | ✗ | return ret; | |
1955 | } | ||
1956 | |||
1957 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 9 times.
|
9 | if (st->codecpar->extradata_size < language_count * 5) |
1958 | ✗ | return AVERROR_INVALIDDATA; | |
1959 | |||
1960 | 9 | extradata = st->codecpar->extradata; | |
1961 | |||
1962 |
2/2✓ Branch 0 taken 9 times.
✓ Branch 1 taken 9 times.
|
18 | for (i = 0; i < language_count; i++) { |
1963 | 9 | language[i * 4 + 0] = get8(pp, desc_end); | |
1964 | 9 | language[i * 4 + 1] = get8(pp, desc_end); | |
1965 | 9 | language[i * 4 + 2] = get8(pp, desc_end); | |
1966 | 9 | language[i * 4 + 3] = ','; | |
1967 | |||
1968 | /* hearing impaired subtitles detection using subtitling_type */ | ||
1969 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 9 times.
|
9 | switch (*pp[0]) { |
1970 | ✗ | case 0x20: /* DVB subtitles (for the hard of hearing) with no monitor aspect ratio criticality */ | |
1971 | case 0x21: /* DVB subtitles (for the hard of hearing) for display on 4:3 aspect ratio monitor */ | ||
1972 | case 0x22: /* DVB subtitles (for the hard of hearing) for display on 16:9 aspect ratio monitor */ | ||
1973 | case 0x23: /* DVB subtitles (for the hard of hearing) for display on 2.21:1 aspect ratio monitor */ | ||
1974 | case 0x24: /* DVB subtitles (for the hard of hearing) for display on a high definition monitor */ | ||
1975 | case 0x25: /* DVB subtitles (for the hard of hearing) with plano-stereoscopic disparity for display on a high definition monitor */ | ||
1976 | ✗ | st->disposition |= AV_DISPOSITION_HEARING_IMPAIRED; | |
1977 | ✗ | break; | |
1978 | } | ||
1979 | |||
1980 | 9 | extradata[4] = get8(pp, desc_end); /* subtitling_type */ | |
1981 | 9 | memcpy(extradata, *pp, 4); /* composition_page_id and ancillary_page_id */ | |
1982 | 9 | extradata += 5; | |
1983 | |||
1984 | 9 | *pp += 4; | |
1985 | } | ||
1986 | |||
1987 | 9 | language[i * 4 - 1] = 0; | |
1988 | 9 | av_dict_set(&st->metadata, "language", language, 0); | |
1989 | 9 | sti->need_context_update = 1; | |
1990 | } | ||
1991 | } | ||
1992 | 9 | break; | |
1993 | 204 | case ISO_639_LANGUAGE_DESCRIPTOR: | |
1994 |
2/2✓ Branch 0 taken 198 times.
✓ Branch 1 taken 204 times.
|
402 | for (i = 0; i + 4 <= desc_len; i += 4) { |
1995 | 198 | language[i + 0] = get8(pp, desc_end); | |
1996 | 198 | language[i + 1] = get8(pp, desc_end); | |
1997 | 198 | language[i + 2] = get8(pp, desc_end); | |
1998 | 198 | language[i + 3] = ','; | |
1999 | 198 | switch (get8(pp, desc_end)) { | |
2000 | ✗ | case 0x01: | |
2001 | ✗ | st->disposition |= AV_DISPOSITION_CLEAN_EFFECTS; | |
2002 | ✗ | break; | |
2003 | ✗ | case 0x02: | |
2004 | ✗ | st->disposition |= AV_DISPOSITION_HEARING_IMPAIRED; | |
2005 | ✗ | break; | |
2006 | 44 | case 0x03: | |
2007 | 44 | st->disposition |= AV_DISPOSITION_VISUAL_IMPAIRED; | |
2008 | 44 | st->disposition |= AV_DISPOSITION_DESCRIPTIONS; | |
2009 | 44 | break; | |
2010 | } | ||
2011 | } | ||
2012 |
4/4✓ Branch 0 taken 198 times.
✓ Branch 1 taken 6 times.
✓ Branch 2 taken 194 times.
✓ Branch 3 taken 4 times.
|
204 | if (i && language[0]) { |
2013 | 194 | language[i - 1] = 0; | |
2014 | /* don't overwrite language, as it may already have been set by | ||
2015 | * another, more specific descriptor (e.g. supplementary audio) */ | ||
2016 | 194 | av_dict_set(&st->metadata, "language", language, AV_DICT_DONT_OVERWRITE); | |
2017 | } | ||
2018 | 204 | break; | |
2019 | 8 | case REGISTRATION_DESCRIPTOR: | |
2020 | 8 | st->codecpar->codec_tag = bytestream_get_le32(pp); | |
2021 | 8 | av_log(fc, AV_LOG_TRACE, "reg_desc=%.4s\n", (char *)&st->codecpar->codec_tag); | |
2022 |
3/4✓ Branch 0 taken 8 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 3 times.
✓ Branch 3 taken 5 times.
|
8 | if (st->codecpar->codec_id == AV_CODEC_ID_NONE || sti->request_probe > 0) { |
2023 | 3 | mpegts_find_stream_type(st, st->codecpar->codec_tag, REGD_types); | |
2024 |
2/2✓ Branch 0 taken 2 times.
✓ Branch 1 taken 1 times.
|
3 | if (st->codecpar->codec_tag == MKTAG('B', 'S', 'S', 'D')) |
2025 | 2 | sti->request_probe = 50; | |
2026 | } | ||
2027 | 8 | break; | |
2028 | 31 | case 0x52: /* stream identifier descriptor */ | |
2029 | 31 | sti->stream_identifier = 1 + get8(pp, desc_end); | |
2030 | 31 | break; | |
2031 | 4 | case METADATA_DESCRIPTOR: | |
2032 |
1/2✓ Branch 1 taken 4 times.
✗ Branch 2 not taken.
|
4 | if (get16(pp, desc_end) == 0xFFFF) |
2033 | 4 | *pp += 4; | |
2034 |
1/2✓ Branch 1 taken 4 times.
✗ Branch 2 not taken.
|
4 | if (get8(pp, desc_end) == 0xFF) { |
2035 | 4 | st->codecpar->codec_tag = bytestream_get_le32(pp); | |
2036 |
2/2✓ Branch 0 taken 1 times.
✓ Branch 1 taken 3 times.
|
4 | if (st->codecpar->codec_id == AV_CODEC_ID_NONE) |
2037 | 1 | mpegts_find_stream_type(st, st->codecpar->codec_tag, METADATA_types); | |
2038 | } | ||
2039 | 4 | break; | |
2040 | 4 | case 0x7f: /* DVB extension descriptor */ | |
2041 | 4 | ext_desc_tag = get8(pp, desc_end); | |
2042 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 4 times.
|
4 | if (ext_desc_tag < 0) |
2043 | ✗ | return AVERROR_INVALIDDATA; | |
2044 |
3/4✓ Branch 0 taken 3 times.
✓ Branch 1 taken 1 times.
✓ Branch 2 taken 3 times.
✗ Branch 3 not taken.
|
4 | if (st->codecpar->codec_id == AV_CODEC_ID_OPUS && |
2045 | ext_desc_tag == 0x80) { /* User defined (provisional Opus) */ | ||
2046 |
2/2✓ Branch 0 taken 1 times.
✓ Branch 1 taken 2 times.
|
3 | if (!st->codecpar->extradata) { |
2047 | 1 | st->codecpar->extradata = av_mallocz(sizeof(opus_default_extradata) + | |
2048 | AV_INPUT_BUFFER_PADDING_SIZE); | ||
2049 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 1 times.
|
1 | if (!st->codecpar->extradata) |
2050 | ✗ | return AVERROR(ENOMEM); | |
2051 | |||
2052 | 1 | st->codecpar->extradata_size = sizeof(opus_default_extradata); | |
2053 | 1 | memcpy(st->codecpar->extradata, opus_default_extradata, sizeof(opus_default_extradata)); | |
2054 | |||
2055 | 1 | channel_config_code = get8(pp, desc_end); | |
2056 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 1 times.
|
1 | if (channel_config_code < 0) |
2057 | ✗ | return AVERROR_INVALIDDATA; | |
2058 |
1/2✓ Branch 0 taken 1 times.
✗ Branch 1 not taken.
|
1 | if (channel_config_code <= 0x8) { |
2059 |
1/2✓ Branch 0 taken 1 times.
✗ Branch 1 not taken.
|
1 | st->codecpar->extradata[9] = channels = channel_config_code ? channel_config_code : 2; |
2060 | 1 | AV_WL32(&st->codecpar->extradata[12], 48000); | |
2061 |
1/2✓ Branch 0 taken 1 times.
✗ Branch 1 not taken.
|
1 | st->codecpar->extradata[18] = channel_config_code ? (channels > 2) : /* Dual Mono */ 255; |
2062 | 1 | st->codecpar->extradata[19] = opus_stream_cnt[channel_config_code]; | |
2063 | 1 | st->codecpar->extradata[20] = opus_coupled_stream_cnt[channel_config_code]; | |
2064 | 1 | memcpy(&st->codecpar->extradata[21], opus_channel_map[channels - 1], channels); | |
2065 |
1/2✓ Branch 0 taken 1 times.
✗ Branch 1 not taken.
|
1 | st->codecpar->extradata_size = st->codecpar->extradata[18] ? 21 + channels : 19; |
2066 | } else { | ||
2067 | ✗ | avpriv_request_sample(fc, "Opus in MPEG-TS - channel_config_code > 0x8"); | |
2068 | } | ||
2069 | 1 | sti->need_parsing = AVSTREAM_PARSE_FULL; | |
2070 | 1 | sti->need_context_update = 1; | |
2071 | } | ||
2072 | } | ||
2073 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 4 times.
|
4 | if (ext_desc_tag == 0x06) { /* supplementary audio descriptor */ |
2074 | int flags; | ||
2075 | |||
2076 | ✗ | if (desc_len < 1) | |
2077 | ✗ | return AVERROR_INVALIDDATA; | |
2078 | ✗ | flags = get8(pp, desc_end); | |
2079 | |||
2080 | ✗ | if ((flags & 0x80) == 0) /* mix_type */ | |
2081 | ✗ | st->disposition |= AV_DISPOSITION_DEPENDENT; | |
2082 | |||
2083 | ✗ | switch ((flags >> 2) & 0x1F) { /* editorial_classification */ | |
2084 | ✗ | case 0x01: | |
2085 | ✗ | st->disposition |= AV_DISPOSITION_VISUAL_IMPAIRED; | |
2086 | ✗ | st->disposition |= AV_DISPOSITION_DESCRIPTIONS; | |
2087 | ✗ | break; | |
2088 | ✗ | case 0x02: | |
2089 | ✗ | st->disposition |= AV_DISPOSITION_HEARING_IMPAIRED; | |
2090 | ✗ | break; | |
2091 | ✗ | case 0x03: | |
2092 | ✗ | st->disposition |= AV_DISPOSITION_VISUAL_IMPAIRED; | |
2093 | ✗ | break; | |
2094 | } | ||
2095 | |||
2096 | ✗ | if (flags & 0x01) { /* language_code_present */ | |
2097 | ✗ | if (desc_len < 4) | |
2098 | ✗ | return AVERROR_INVALIDDATA; | |
2099 | ✗ | language[0] = get8(pp, desc_end); | |
2100 | ✗ | language[1] = get8(pp, desc_end); | |
2101 | ✗ | language[2] = get8(pp, desc_end); | |
2102 | ✗ | language[3] = 0; | |
2103 | |||
2104 | /* This language always has to override a possible | ||
2105 | * ISO 639 language descriptor language */ | ||
2106 | ✗ | if (language[0]) | |
2107 | ✗ | av_dict_set(&st->metadata, "language", language, 0); | |
2108 | } | ||
2109 | } | ||
2110 | 4 | break; | |
2111 | 6 | case 0x6a: /* ac-3_descriptor */ | |
2112 | { | ||
2113 | 6 | int component_type_flag = get8(pp, desc_end) & (1 << 7); | |
2114 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 6 times.
|
6 | if (component_type_flag) { |
2115 | ✗ | int component_type = get8(pp, desc_end); | |
2116 | ✗ | int service_type_mask = 0x38; // 0b00111000 | |
2117 | ✗ | int service_type = ((component_type & service_type_mask) >> 3); | |
2118 | ✗ | if (service_type == 0x02 /* 0b010 */) { | |
2119 | ✗ | st->disposition |= AV_DISPOSITION_DESCRIPTIONS; | |
2120 | ✗ | av_log(ts ? ts->stream : fc, AV_LOG_DEBUG, "New track disposition for id %u: %u\n", st->id, st->disposition); | |
2121 | } | ||
2122 | } | ||
2123 | } | ||
2124 | 6 | break; | |
2125 | ✗ | case 0x7a: /* enhanced_ac-3_descriptor */ | |
2126 | { | ||
2127 | ✗ | int component_type_flag = get8(pp, desc_end) & (1 << 7); | |
2128 | ✗ | if (component_type_flag) { | |
2129 | ✗ | int component_type = get8(pp, desc_end); | |
2130 | ✗ | int service_type_mask = 0x38; // 0b00111000 | |
2131 | ✗ | int service_type = ((component_type & service_type_mask) >> 3); | |
2132 | ✗ | if (service_type == 0x02 /* 0b010 */) { | |
2133 | ✗ | st->disposition |= AV_DISPOSITION_DESCRIPTIONS; | |
2134 | ✗ | av_log(ts ? ts->stream : fc, AV_LOG_DEBUG, "New track disposition for id %u: %u\n", st->id, st->disposition); | |
2135 | } | ||
2136 | } | ||
2137 | } | ||
2138 | ✗ | break; | |
2139 | ✗ | case 0xfd: /* ARIB data coding type descriptor */ | |
2140 | // STD-B24, fascicle 3, chapter 4 defines private_stream_1 | ||
2141 | // for captions | ||
2142 | ✗ | if (stream_type == STREAM_TYPE_PRIVATE_DATA) { | |
2143 | // This structure is defined in STD-B10, part 1, listing 5.4 and | ||
2144 | // part 2, 6.2.20). | ||
2145 | // Listing of data_component_ids is in STD-B10, part 2, Annex J. | ||
2146 | // Component tag limits are documented in TR-B14, fascicle 2, | ||
2147 | // Vol. 3, Section 2, 4.2.8.1 | ||
2148 | ✗ | int actual_component_tag = sti->stream_identifier - 1; | |
2149 | ✗ | int picked_profile = AV_PROFILE_UNKNOWN; | |
2150 | ✗ | int data_component_id = get16(pp, desc_end); | |
2151 | ✗ | if (data_component_id < 0) | |
2152 | ✗ | return AVERROR_INVALIDDATA; | |
2153 | |||
2154 | switch (data_component_id) { | ||
2155 | ✗ | case 0x0008: | |
2156 | // [0x30..0x37] are component tags utilized for | ||
2157 | // non-mobile captioning service ("profile A"). | ||
2158 | ✗ | if (actual_component_tag >= 0x30 && | |
2159 | actual_component_tag <= 0x37) { | ||
2160 | ✗ | picked_profile = AV_PROFILE_ARIB_PROFILE_A; | |
2161 | } | ||
2162 | ✗ | break; | |
2163 | ✗ | case 0x0012: | |
2164 | // component tag 0x87 signifies a mobile/partial reception | ||
2165 | // (1seg) captioning service ("profile C"). | ||
2166 | ✗ | if (actual_component_tag == 0x87) { | |
2167 | ✗ | picked_profile = AV_PROFILE_ARIB_PROFILE_C; | |
2168 | } | ||
2169 | ✗ | break; | |
2170 | ✗ | default: | |
2171 | ✗ | break; | |
2172 | } | ||
2173 | |||
2174 | ✗ | if (picked_profile == AV_PROFILE_UNKNOWN) | |
2175 | ✗ | break; | |
2176 | |||
2177 | ✗ | st->codecpar->codec_type = AVMEDIA_TYPE_SUBTITLE; | |
2178 | ✗ | st->codecpar->codec_id = AV_CODEC_ID_ARIB_CAPTION; | |
2179 | ✗ | if (st->codecpar->profile != picked_profile) { | |
2180 | ✗ | st->codecpar->profile = picked_profile; | |
2181 | ✗ | sti->need_context_update = 1; | |
2182 | } | ||
2183 | ✗ | sti->request_probe = 0; | |
2184 | ✗ | sti->need_parsing = 0; | |
2185 | } | ||
2186 | ✗ | break; | |
2187 | ✗ | case 0xb0: /* DOVI video stream descriptor */ | |
2188 | { | ||
2189 | uint32_t buf; | ||
2190 | AVDOVIDecoderConfigurationRecord *dovi; | ||
2191 | size_t dovi_size; | ||
2192 | ✗ | int dependency_pid = -1; // Unset | |
2193 | |||
2194 | ✗ | if (desc_end - *pp < 4) // (8 + 8 + 7 + 6 + 1 + 1 + 1) / 8 | |
2195 | ✗ | return AVERROR_INVALIDDATA; | |
2196 | |||
2197 | ✗ | dovi = av_dovi_alloc(&dovi_size); | |
2198 | ✗ | if (!dovi) | |
2199 | ✗ | return AVERROR(ENOMEM); | |
2200 | |||
2201 | ✗ | dovi->dv_version_major = get8(pp, desc_end); | |
2202 | ✗ | dovi->dv_version_minor = get8(pp, desc_end); | |
2203 | ✗ | buf = get16(pp, desc_end); | |
2204 | ✗ | dovi->dv_profile = (buf >> 9) & 0x7f; // 7 bits | |
2205 | ✗ | dovi->dv_level = (buf >> 3) & 0x3f; // 6 bits | |
2206 | ✗ | dovi->rpu_present_flag = (buf >> 2) & 0x01; // 1 bit | |
2207 | ✗ | dovi->el_present_flag = (buf >> 1) & 0x01; // 1 bit | |
2208 | ✗ | dovi->bl_present_flag = buf & 0x01; // 1 bit | |
2209 | ✗ | if (!dovi->bl_present_flag && desc_end - *pp >= 2) { | |
2210 | ✗ | buf = get16(pp, desc_end); | |
2211 | ✗ | dependency_pid = buf >> 3; // 13 bits | |
2212 | } | ||
2213 | ✗ | if (desc_end - *pp >= 1) { // 8 bits | |
2214 | ✗ | buf = get8(pp, desc_end); | |
2215 | ✗ | dovi->dv_bl_signal_compatibility_id = (buf >> 4) & 0x0f; // 4 bits | |
2216 | } else { | ||
2217 | // 0 stands for None | ||
2218 | // Dolby Vision V1.2.93 profiles and levels | ||
2219 | ✗ | dovi->dv_bl_signal_compatibility_id = 0; | |
2220 | } | ||
2221 | |||
2222 | ✗ | if (!av_packet_side_data_add(&st->codecpar->coded_side_data, | |
2223 | ✗ | &st->codecpar->nb_coded_side_data, | |
2224 | AV_PKT_DATA_DOVI_CONF, | ||
2225 | (uint8_t *)dovi, dovi_size, 0)) { | ||
2226 | ✗ | av_free(dovi); | |
2227 | ✗ | return AVERROR(ENOMEM); | |
2228 | } | ||
2229 | |||
2230 | ✗ | av_log(fc, AV_LOG_TRACE, "DOVI, version: %d.%d, profile: %d, level: %d, " | |
2231 | "rpu flag: %d, el flag: %d, bl flag: %d, dependency_pid: %d, compatibility id: %d\n", | ||
2232 | ✗ | dovi->dv_version_major, dovi->dv_version_minor, | |
2233 | ✗ | dovi->dv_profile, dovi->dv_level, | |
2234 | ✗ | dovi->rpu_present_flag, | |
2235 | ✗ | dovi->el_present_flag, | |
2236 | ✗ | dovi->bl_present_flag, | |
2237 | dependency_pid, | ||
2238 | ✗ | dovi->dv_bl_signal_compatibility_id); | |
2239 | } | ||
2240 | ✗ | break; | |
2241 | 60 | default: | |
2242 | 60 | break; | |
2243 | } | ||
2244 | 326 | *pp = desc_end; | |
2245 | 326 | return 0; | |
2246 | } | ||
2247 | |||
2248 | 12 | static AVStream *find_matching_stream(MpegTSContext *ts, int pid, unsigned int programid, | |
2249 | int stream_identifier, int pmt_stream_idx, struct Program *p) | ||
2250 | { | ||
2251 | 12 | AVFormatContext *s = ts->stream; | |
2252 | 12 | AVStream *found = NULL; | |
2253 | |||
2254 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 12 times.
|
12 | if (stream_identifier) { /* match based on "stream identifier descriptor" if present */ |
2255 | ✗ | for (int i = 0; i < p->nb_streams; i++) { | |
2256 | ✗ | if (p->streams[i].stream_identifier == stream_identifier) | |
2257 | ✗ | if (!found || pmt_stream_idx == i) /* fallback to idx based guess if multiple streams have the same identifier */ | |
2258 | ✗ | found = s->streams[p->streams[i].idx]; | |
2259 | } | ||
2260 |
2/2✓ Branch 0 taken 7 times.
✓ Branch 1 taken 5 times.
|
12 | } else if (pmt_stream_idx < p->nb_streams) { /* match based on position within the PMT */ |
2261 | 7 | found = s->streams[p->streams[pmt_stream_idx].idx]; | |
2262 | } | ||
2263 | |||
2264 |
2/2✓ Branch 0 taken 7 times.
✓ Branch 1 taken 5 times.
|
12 | if (found) { |
2265 | 7 | av_log(ts->stream, AV_LOG_VERBOSE, | |
2266 | "re-using existing %s stream %d (pid=0x%x) for new pid=0x%x\n", | ||
2267 | 7 | av_get_media_type_string(found->codecpar->codec_type), | |
2268 | found->index, found->id, pid); | ||
2269 | } | ||
2270 | |||
2271 | 12 | return found; | |
2272 | } | ||
2273 | |||
2274 | 519 | static int parse_stream_identifier_desc(const uint8_t *p, const uint8_t *p_end) | |
2275 | { | ||
2276 | 519 | const uint8_t **pp = &p; | |
2277 | const uint8_t *desc_list_end; | ||
2278 | const uint8_t *desc_end; | ||
2279 | int desc_list_len; | ||
2280 | int desc_len, desc_tag; | ||
2281 | |||
2282 | 519 | desc_list_len = get16(pp, p_end); | |
2283 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 519 times.
|
519 | if (desc_list_len < 0) |
2284 | ✗ | return -1; | |
2285 | 519 | desc_list_len &= 0xfff; | |
2286 | 519 | desc_list_end = p + desc_list_len; | |
2287 |
1/2✓ Branch 0 taken 519 times.
✗ Branch 1 not taken.
|
519 | if (desc_list_end > p_end) |
2288 | ✗ | return -1; | |
2289 | |||
2290 | while (1) { | ||
2291 | 805 | desc_tag = get8(pp, desc_list_end); | |
2292 |
2/2✓ Branch 0 taken 491 times.
✓ Branch 1 taken 314 times.
|
805 | if (desc_tag < 0) |
2293 | 491 | return -1; | |
2294 | 314 | desc_len = get8(pp, desc_list_end); | |
2295 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 314 times.
|
314 | if (desc_len < 0) |
2296 | ✗ | return -1; | |
2297 | 314 | desc_end = *pp + desc_len; | |
2298 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 314 times.
|
314 | if (desc_end > desc_list_end) |
2299 | ✗ | return -1; | |
2300 | |||
2301 |
2/2✓ Branch 0 taken 28 times.
✓ Branch 1 taken 286 times.
|
314 | if (desc_tag == 0x52) { |
2302 | 28 | return get8(pp, desc_end); | |
2303 | } | ||
2304 | 286 | *pp = desc_end; | |
2305 | } | ||
2306 | |||
2307 | return -1; | ||
2308 | } | ||
2309 | |||
2310 | 123 | static int is_pes_stream(int stream_type, uint32_t prog_reg_desc) | |
2311 | { | ||
2312 |
3/4✓ Branch 0 taken 123 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 22 times.
✓ Branch 3 taken 101 times.
|
145 | return !(stream_type == 0x13 || |
2313 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 22 times.
|
22 | (stream_type == 0x86 && prog_reg_desc == AV_RL32("CUEI")) ); |
2314 | } | ||
2315 | |||
2316 | 2940 | static void pmt_cb(MpegTSFilter *filter, const uint8_t *section, int section_len) | |
2317 | { | ||
2318 | 2940 | MpegTSContext *ts = filter->u.section_filter.opaque; | |
2319 | 2940 | MpegTSSectionFilter *tssf = &filter->u.section_filter; | |
2320 | struct Program old_program; | ||
2321 | 2940 | SectionHeader h1, *h = &h1; | |
2322 | PESContext *pes; | ||
2323 | AVStream *st; | ||
2324 | const uint8_t *p, *p_end, *desc_list_end; | ||
2325 | int program_info_length, pcr_pid, pid, stream_type; | ||
2326 | int desc_list_len; | ||
2327 | 2940 | uint32_t prog_reg_desc = 0; /* registration descriptor */ | |
2328 | 2940 | int stream_identifier = -1; | |
2329 | struct Program *prg; | ||
2330 | |||
2331 | 2940 | int mp4_descr_count = 0; | |
2332 | 2940 | Mp4Descr mp4_descr[MAX_MP4_DESCR_COUNT] = { { 0 } }; | |
2333 | int i; | ||
2334 | |||
2335 | 2940 | av_log(ts->stream, AV_LOG_TRACE, "PMT: len %i\n", section_len); | |
2336 | hex_dump_debug(ts->stream, section, section_len); | ||
2337 | |||
2338 | 2940 | p_end = section + section_len - 4; | |
2339 | 2940 | p = section; | |
2340 |
1/2✗ Branch 1 not taken.
✓ Branch 2 taken 2940 times.
|
2940 | if (parse_section_header(h, &p, p_end) < 0) |
2341 | 2677 | return; | |
2342 |
2/2✓ Branch 0 taken 55 times.
✓ Branch 1 taken 2885 times.
|
2940 | if (h->tid != PMT_TID) |
2343 | 55 | return; | |
2344 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 2885 times.
|
2885 | if (!h->current_next) |
2345 | ✗ | return; | |
2346 |
2/2✓ Branch 1 taken 2622 times.
✓ Branch 2 taken 263 times.
|
2885 | if (skip_identical(h, tssf)) |
2347 | 2622 | return; | |
2348 | |||
2349 | 263 | av_log(ts->stream, AV_LOG_TRACE, "sid=0x%x sec_num=%d/%d version=%d tid=%d\n", | |
2350 | 263 | h->id, h->sec_num, h->last_sec_num, h->version, h->tid); | |
2351 | |||
2352 |
1/4✗ Branch 0 not taken.
✓ Branch 1 taken 263 times.
✗ Branch 2 not taken.
✗ Branch 3 not taken.
|
263 | if (!ts->scan_all_pmts && ts->skip_changes) |
2353 | ✗ | return; | |
2354 | |||
2355 | 263 | prg = get_program(ts, h->id); | |
2356 |
1/2✓ Branch 0 taken 263 times.
✗ Branch 1 not taken.
|
263 | if (prg) |
2357 | 263 | old_program = *prg; | |
2358 | else | ||
2359 | ✗ | clear_program(&old_program); | |
2360 | |||
2361 |
1/4✗ Branch 0 not taken.
✓ Branch 1 taken 263 times.
✗ Branch 2 not taken.
✗ Branch 3 not taken.
|
263 | if (ts->skip_unknown_pmt && !prg) |
2362 | ✗ | return; | |
2363 |
3/6✓ Branch 0 taken 263 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 263 times.
✗ Branch 3 not taken.
✗ Branch 4 not taken.
✓ Branch 5 taken 263 times.
|
263 | if (prg && prg->nb_pids && prg->pids[0] != ts->current_pid) |
2364 | ✗ | return; | |
2365 |
2/2✓ Branch 0 taken 169 times.
✓ Branch 1 taken 94 times.
|
263 | if (!ts->skip_clear) |
2366 | 169 | clear_avprogram(ts, h->id); | |
2367 | 263 | clear_program(prg); | |
2368 | 263 | add_pid_to_program(prg, ts->current_pid); | |
2369 | |||
2370 | 263 | pcr_pid = get16(&p, p_end); | |
2371 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 263 times.
|
263 | if (pcr_pid < 0) |
2372 | ✗ | return; | |
2373 | 263 | pcr_pid &= 0x1fff; | |
2374 | 263 | add_pid_to_program(prg, pcr_pid); | |
2375 | 263 | update_av_program_info(ts->stream, h->id, pcr_pid, h->version); | |
2376 | |||
2377 | 263 | av_log(ts->stream, AV_LOG_TRACE, "pcr_pid=0x%x\n", pcr_pid); | |
2378 | |||
2379 | 263 | program_info_length = get16(&p, p_end); | |
2380 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 263 times.
|
263 | if (program_info_length < 0) |
2381 | ✗ | return; | |
2382 | 263 | program_info_length &= 0xfff; | |
2383 |
2/2✓ Branch 0 taken 190 times.
✓ Branch 1 taken 263 times.
|
453 | while (program_info_length >= 2) { |
2384 | uint8_t tag, len; | ||
2385 | 190 | tag = get8(&p, p_end); | |
2386 | 190 | len = get8(&p, p_end); | |
2387 | |||
2388 | 190 | av_log(ts->stream, AV_LOG_TRACE, "program tag: 0x%02x len=%d\n", tag, len); | |
2389 | |||
2390 | 190 | program_info_length -= 2; | |
2391 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 190 times.
|
190 | if (len > program_info_length) |
2392 | // something else is broken, exit the program_descriptors_loop | ||
2393 | ✗ | break; | |
2394 | 190 | program_info_length -= len; | |
2395 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 190 times.
|
190 | if (tag == IOD_DESCRIPTOR) { |
2396 | ✗ | get8(&p, p_end); // scope | |
2397 | ✗ | get8(&p, p_end); // label | |
2398 | ✗ | len -= 2; | |
2399 | ✗ | mp4_read_iods(ts->stream, p, len, mp4_descr + mp4_descr_count, | |
2400 | &mp4_descr_count, MAX_MP4_DESCR_COUNT); | ||
2401 |
3/4✓ Branch 0 taken 88 times.
✓ Branch 1 taken 102 times.
✓ Branch 2 taken 88 times.
✗ Branch 3 not taken.
|
190 | } else if (tag == REGISTRATION_DESCRIPTOR && len >= 4) { |
2402 | 88 | prog_reg_desc = bytestream_get_le32(&p); | |
2403 | 88 | len -= 4; | |
2404 | } | ||
2405 | 190 | p += len; | |
2406 | } | ||
2407 | 263 | p += program_info_length; | |
2408 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 263 times.
|
263 | if (p >= p_end) |
2409 | ✗ | goto out; | |
2410 | |||
2411 | // stop parsing after pmt, we found header | ||
2412 |
2/2✓ Branch 0 taken 54 times.
✓ Branch 1 taken 209 times.
|
263 | if (!ts->pkt) |
2413 | 54 | ts->stop_parse = 2; | |
2414 | |||
2415 |
1/2✓ Branch 0 taken 263 times.
✗ Branch 1 not taken.
|
263 | if (prg) |
2416 | 263 | prg->pmt_found = 1; | |
2417 | |||
2418 |
1/2✓ Branch 0 taken 782 times.
✗ Branch 1 not taken.
|
782 | for (i = 0; i < MAX_STREAMS_PER_PROGRAM; i++) { |
2419 | 782 | st = 0; | |
2420 | 782 | pes = NULL; | |
2421 | 782 | stream_type = get8(&p, p_end); | |
2422 |
2/2✓ Branch 0 taken 263 times.
✓ Branch 1 taken 519 times.
|
782 | if (stream_type < 0) |
2423 | 263 | break; | |
2424 | 519 | pid = get16(&p, p_end); | |
2425 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 519 times.
|
519 | if (pid < 0) |
2426 | ✗ | goto out; | |
2427 | 519 | pid &= 0x1fff; | |
2428 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 519 times.
|
519 | if (pid == ts->current_pid) |
2429 | ✗ | goto out; | |
2430 | |||
2431 | 519 | stream_identifier = parse_stream_identifier_desc(p, p_end) + 1; | |
2432 | |||
2433 | /* now create stream */ | ||
2434 |
4/4✓ Branch 0 taken 410 times.
✓ Branch 1 taken 109 times.
✓ Branch 2 taken 396 times.
✓ Branch 3 taken 14 times.
|
519 | if (ts->pids[pid] && ts->pids[pid]->type == MPEGTS_PES) { |
2435 | 396 | pes = ts->pids[pid]->u.pes_filter.opaque; | |
2436 |
3/4✓ Branch 0 taken 16 times.
✓ Branch 1 taken 380 times.
✗ Branch 2 not taken.
✓ Branch 3 taken 16 times.
|
396 | if (ts->merge_pmt_versions && !pes->st) { |
2437 | ✗ | st = find_matching_stream(ts, pid, h->id, stream_identifier, i, &old_program); | |
2438 | ✗ | if (st) { | |
2439 | ✗ | pes->st = st; | |
2440 | ✗ | pes->stream_type = stream_type; | |
2441 | ✗ | pes->merged_st = 1; | |
2442 | } | ||
2443 | } | ||
2444 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 396 times.
|
396 | if (!pes->st) { |
2445 | ✗ | pes->st = avformat_new_stream(pes->stream, NULL); | |
2446 | ✗ | if (!pes->st) | |
2447 | ✗ | goto out; | |
2448 | ✗ | pes->st->id = pes->pid; | |
2449 | } | ||
2450 | 396 | st = pes->st; | |
2451 |
2/2✓ Branch 1 taken 101 times.
✓ Branch 2 taken 22 times.
|
123 | } else if (is_pes_stream(stream_type, prog_reg_desc)) { |
2452 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 101 times.
|
101 | if (ts->pids[pid]) |
2453 | ✗ | mpegts_close_filter(ts, ts->pids[pid]); // wrongly added sdt filter probably | |
2454 | 101 | pes = add_pes_stream(ts, pid, pcr_pid); | |
2455 |
4/6✓ Branch 0 taken 8 times.
✓ Branch 1 taken 93 times.
✓ Branch 2 taken 8 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 8 times.
✗ Branch 5 not taken.
|
101 | if (ts->merge_pmt_versions && pes && !pes->st) { |
2456 | 8 | st = find_matching_stream(ts, pid, h->id, stream_identifier, i, &old_program); | |
2457 |
2/2✓ Branch 0 taken 4 times.
✓ Branch 1 taken 4 times.
|
8 | if (st) { |
2458 | 4 | pes->st = st; | |
2459 | 4 | pes->stream_type = stream_type; | |
2460 | 4 | pes->merged_st = 1; | |
2461 | } | ||
2462 | } | ||
2463 |
3/4✓ Branch 0 taken 101 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 97 times.
✓ Branch 3 taken 4 times.
|
101 | if (pes && !pes->st) { |
2464 | 97 | st = avformat_new_stream(pes->stream, NULL); | |
2465 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 97 times.
|
97 | if (!st) |
2466 | ✗ | goto out; | |
2467 | 97 | st->id = pes->pid; | |
2468 | } | ||
2469 | } else { | ||
2470 | 22 | int idx = ff_find_stream_index(ts->stream, pid); | |
2471 |
2/2✓ Branch 0 taken 14 times.
✓ Branch 1 taken 8 times.
|
22 | if (idx >= 0) { |
2472 | 14 | st = ts->stream->streams[idx]; | |
2473 | } | ||
2474 |
4/4✓ Branch 0 taken 6 times.
✓ Branch 1 taken 16 times.
✓ Branch 2 taken 4 times.
✓ Branch 3 taken 2 times.
|
22 | if (ts->merge_pmt_versions && !st) { |
2475 | 4 | st = find_matching_stream(ts, pid, h->id, stream_identifier, i, &old_program); | |
2476 | } | ||
2477 |
2/2✓ Branch 0 taken 5 times.
✓ Branch 1 taken 17 times.
|
22 | if (!st) { |
2478 | 5 | st = avformat_new_stream(ts->stream, NULL); | |
2479 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 5 times.
|
5 | if (!st) |
2480 | ✗ | goto out; | |
2481 | 5 | st->id = pid; | |
2482 | 5 | st->codecpar->codec_type = AVMEDIA_TYPE_DATA; | |
2483 |
2/4✓ Branch 0 taken 5 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 5 times.
✗ Branch 3 not taken.
|
5 | if (stream_type == 0x86 && prog_reg_desc == AV_RL32("CUEI")) { |
2484 | 5 | mpegts_find_stream_type(st, stream_type, SCTE_types); | |
2485 | 5 | mpegts_open_section_filter(ts, pid, scte_data_cb, ts, 1); | |
2486 | } | ||
2487 | } | ||
2488 | } | ||
2489 | |||
2490 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 519 times.
|
519 | if (!st) |
2491 | ✗ | goto out; | |
2492 | |||
2493 |
4/4✓ Branch 0 taken 497 times.
✓ Branch 1 taken 22 times.
✓ Branch 2 taken 97 times.
✓ Branch 3 taken 400 times.
|
519 | if (pes && !pes->stream_type) |
2494 | 97 | mpegts_set_stream_info(st, pes, stream_type, prog_reg_desc); | |
2495 | |||
2496 | 519 | add_pid_to_program(prg, pid); | |
2497 |
1/2✓ Branch 0 taken 519 times.
✗ Branch 1 not taken.
|
519 | if (prg) { |
2498 | 519 | prg->streams[i].idx = st->index; | |
2499 | 519 | prg->streams[i].stream_identifier = stream_identifier; | |
2500 | 519 | prg->nb_streams++; | |
2501 | } | ||
2502 | |||
2503 | 519 | av_program_add_stream_index(ts->stream, h->id, st->index); | |
2504 | |||
2505 | 519 | desc_list_len = get16(&p, p_end); | |
2506 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 519 times.
|
519 | if (desc_list_len < 0) |
2507 | ✗ | goto out; | |
2508 | 519 | desc_list_len &= 0xfff; | |
2509 | 519 | desc_list_end = p + desc_list_len; | |
2510 |
1/2✓ Branch 0 taken 519 times.
✗ Branch 1 not taken.
|
519 | if (desc_list_end > p_end) |
2511 | ✗ | goto out; | |
2512 | for (;;) { | ||
2513 |
2/2✓ Branch 1 taken 519 times.
✓ Branch 2 taken 322 times.
|
841 | if (ff_parse_mpeg2_descriptor(ts->stream, st, stream_type, &p, |
2514 | desc_list_end, mp4_descr, | ||
2515 | mp4_descr_count, pid, ts) < 0) | ||
2516 | 519 | break; | |
2517 | |||
2518 |
2/6✓ Branch 0 taken 322 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 322 times.
✗ Branch 4 not taken.
✗ Branch 5 not taken.
|
322 | if (pes && prog_reg_desc == AV_RL32("HDMV") && |
2519 | ✗ | stream_type == 0x83 && pes->sub_st) { | |
2520 | ✗ | av_program_add_stream_index(ts->stream, h->id, | |
2521 | ✗ | pes->sub_st->index); | |
2522 | ✗ | pes->sub_st->codecpar->codec_tag = st->codecpar->codec_tag; | |
2523 | } | ||
2524 | } | ||
2525 | 519 | p = desc_list_end; | |
2526 | } | ||
2527 | |||
2528 |
1/2✓ Branch 0 taken 263 times.
✗ Branch 1 not taken.
|
263 | if (!ts->pids[pcr_pid]) |
2529 | ✗ | mpegts_open_pcr_filter(ts, pcr_pid); | |
2530 | |||
2531 | 263 | out: | |
2532 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 263 times.
|
263 | for (i = 0; i < mp4_descr_count; i++) |
2533 | ✗ | av_free(mp4_descr[i].dec_config_descr); | |
2534 | } | ||
2535 | |||
2536 | 2975 | static void pat_cb(MpegTSFilter *filter, const uint8_t *section, int section_len) | |
2537 | { | ||
2538 | 2975 | MpegTSContext *ts = filter->u.section_filter.opaque; | |
2539 | 2975 | MpegTSSectionFilter *tssf = &filter->u.section_filter; | |
2540 | 2975 | SectionHeader h1, *h = &h1; | |
2541 | const uint8_t *p, *p_end; | ||
2542 | int sid, pmt_pid; | ||
2543 | 2975 | int nb_prg = 0; | |
2544 | AVProgram *program; | ||
2545 | |||
2546 | 2975 | av_log(ts->stream, AV_LOG_TRACE, "PAT:\n"); | |
2547 | hex_dump_debug(ts->stream, section, section_len); | ||
2548 | |||
2549 | 2975 | p_end = section + section_len - 4; | |
2550 | 2975 | p = section; | |
2551 |
1/2✗ Branch 1 not taken.
✓ Branch 2 taken 2975 times.
|
2975 | if (parse_section_header(h, &p, p_end) < 0) |
2552 | 2765 | return; | |
2553 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 2975 times.
|
2975 | if (h->tid != PAT_TID) |
2554 | ✗ | return; | |
2555 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 2975 times.
|
2975 | if (!h->current_next) |
2556 | ✗ | return; | |
2557 |
2/2✓ Branch 0 taken 521 times.
✓ Branch 1 taken 2454 times.
|
2975 | if (ts->skip_changes) |
2558 | 521 | return; | |
2559 | |||
2560 |
2/2✓ Branch 1 taken 2244 times.
✓ Branch 2 taken 210 times.
|
2454 | if (skip_identical(h, tssf)) |
2561 | 2244 | return; | |
2562 | 210 | ts->id = h->id; | |
2563 | |||
2564 | for (;;) { | ||
2565 | 420 | sid = get16(&p, p_end); | |
2566 |
2/2✓ Branch 0 taken 210 times.
✓ Branch 1 taken 210 times.
|
420 | if (sid < 0) |
2567 | 210 | break; | |
2568 | 210 | pmt_pid = get16(&p, p_end); | |
2569 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 210 times.
|
210 | if (pmt_pid < 0) |
2570 | ✗ | break; | |
2571 | 210 | pmt_pid &= 0x1fff; | |
2572 | |||
2573 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 210 times.
|
210 | if (pmt_pid == ts->current_pid) |
2574 | ✗ | break; | |
2575 | |||
2576 | 210 | av_log(ts->stream, AV_LOG_TRACE, "sid=0x%x pid=0x%x\n", sid, pmt_pid); | |
2577 | |||
2578 |
1/2✓ Branch 0 taken 210 times.
✗ Branch 1 not taken.
|
210 | if (sid == 0x0000) { |
2579 | /* NIT info */ | ||
2580 | } else { | ||
2581 | 210 | MpegTSFilter *fil = ts->pids[pmt_pid]; | |
2582 | struct Program *prg; | ||
2583 | 210 | program = av_new_program(ts->stream, sid); | |
2584 |
1/2✓ Branch 0 taken 210 times.
✗ Branch 1 not taken.
|
210 | if (program) { |
2585 | 210 | program->program_num = sid; | |
2586 | 210 | program->pmt_pid = pmt_pid; | |
2587 | } | ||
2588 |
2/2✓ Branch 0 taken 156 times.
✓ Branch 1 taken 54 times.
|
210 | if (fil) |
2589 |
1/2✓ Branch 0 taken 156 times.
✗ Branch 1 not taken.
|
156 | if ( fil->type != MPEGTS_SECTION |
2590 |
1/2✓ Branch 0 taken 156 times.
✗ Branch 1 not taken.
|
156 | || fil->pid != pmt_pid |
2591 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 156 times.
|
156 | || fil->u.section_filter.section_cb != pmt_cb) |
2592 | ✗ | mpegts_close_filter(ts, ts->pids[pmt_pid]); | |
2593 | |||
2594 |
2/2✓ Branch 0 taken 54 times.
✓ Branch 1 taken 156 times.
|
210 | if (!ts->pids[pmt_pid]) |
2595 | 54 | mpegts_open_section_filter(ts, pmt_pid, pmt_cb, ts, 1); | |
2596 | 210 | prg = add_program(ts, sid); | |
2597 |
1/2✓ Branch 0 taken 210 times.
✗ Branch 1 not taken.
|
210 | if (prg) { |
2598 | 210 | unsigned prg_idx = prg - ts->prg; | |
2599 |
3/4✓ Branch 0 taken 156 times.
✓ Branch 1 taken 54 times.
✗ Branch 2 not taken.
✓ Branch 3 taken 156 times.
|
210 | if (prg->nb_pids && prg->pids[0] != pmt_pid) |
2600 | ✗ | clear_program(prg); | |
2601 | 210 | add_pid_to_program(prg, pmt_pid); | |
2602 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 210 times.
|
210 | if (prg_idx > nb_prg) |
2603 | ✗ | FFSWAP(struct Program, ts->prg[nb_prg], ts->prg[prg_idx]); | |
2604 |
1/2✓ Branch 0 taken 210 times.
✗ Branch 1 not taken.
|
210 | if (prg_idx >= nb_prg) |
2605 | 210 | nb_prg++; | |
2606 | } else | ||
2607 | ✗ | nb_prg = 0; | |
2608 | } | ||
2609 | } | ||
2610 | 210 | ts->nb_prg = nb_prg; | |
2611 | |||
2612 |
1/2✓ Branch 0 taken 210 times.
✗ Branch 1 not taken.
|
210 | if (sid < 0) { |
2613 | int i,j; | ||
2614 |
2/2✓ Branch 0 taken 210 times.
✓ Branch 1 taken 210 times.
|
420 | for (j=0; j<ts->stream->nb_programs; j++) { |
2615 |
1/2✓ Branch 0 taken 210 times.
✗ Branch 1 not taken.
|
210 | for (i = 0; i < ts->nb_prg; i++) |
2616 |
1/2✓ Branch 0 taken 210 times.
✗ Branch 1 not taken.
|
210 | if (ts->prg[i].id == ts->stream->programs[j]->id) |
2617 | 210 | break; | |
2618 |
1/4✗ Branch 0 not taken.
✓ Branch 1 taken 210 times.
✗ Branch 2 not taken.
✗ Branch 3 not taken.
|
210 | if (i==ts->nb_prg && !ts->skip_clear) |
2619 | ✗ | clear_avprogram(ts, ts->stream->programs[j]->id); | |
2620 | } | ||
2621 | } | ||
2622 | } | ||
2623 | |||
2624 | 14 | static void eit_cb(MpegTSFilter *filter, const uint8_t *section, int section_len) | |
2625 | { | ||
2626 | 14 | MpegTSContext *ts = filter->u.section_filter.opaque; | |
2627 | const uint8_t *p, *p_end; | ||
2628 | 14 | SectionHeader h1, *h = &h1; | |
2629 | |||
2630 | /* | ||
2631 | * Sometimes we receive EPG packets but SDT table do not have | ||
2632 | * eit_pres_following or eit_sched turned on, so we open EPG | ||
2633 | * stream directly here. | ||
2634 | */ | ||
2635 |
2/2✓ Branch 0 taken 3 times.
✓ Branch 1 taken 11 times.
|
14 | if (!ts->epg_stream) { |
2636 | 3 | ts->epg_stream = avformat_new_stream(ts->stream, NULL); | |
2637 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 3 times.
|
3 | if (!ts->epg_stream) |
2638 | 2 | return; | |
2639 | 3 | ts->epg_stream->id = EIT_PID; | |
2640 | 3 | ts->epg_stream->codecpar->codec_type = AVMEDIA_TYPE_DATA; | |
2641 | 3 | ts->epg_stream->codecpar->codec_id = AV_CODEC_ID_EPG; | |
2642 | } | ||
2643 | |||
2644 |
2/2✓ Branch 0 taken 2 times.
✓ Branch 1 taken 12 times.
|
14 | if (ts->epg_stream->discard == AVDISCARD_ALL) |
2645 | 2 | return; | |
2646 | |||
2647 | 12 | p_end = section + section_len - 4; | |
2648 | 12 | p = section; | |
2649 | |||
2650 |
1/2✗ Branch 1 not taken.
✓ Branch 2 taken 12 times.
|
12 | if (parse_section_header(h, &p, p_end) < 0) |
2651 | ✗ | return; | |
2652 |
2/4✓ Branch 0 taken 12 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 12 times.
|
12 | if (h->tid < EIT_TID || h->tid > OEITS_END_TID) |
2653 | ✗ | return; | |
2654 | |||
2655 | 12 | av_log(ts->stream, AV_LOG_TRACE, "EIT: tid received = %.02x\n", h->tid); | |
2656 | |||
2657 | /** | ||
2658 | * Service_id 0xFFFF is reserved, it indicates that the current EIT table | ||
2659 | * is scrambled. | ||
2660 | */ | ||
2661 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 12 times.
|
12 | if (h->id == 0xFFFF) { |
2662 | ✗ | av_log(ts->stream, AV_LOG_TRACE, "Scrambled EIT table received.\n"); | |
2663 | ✗ | return; | |
2664 | } | ||
2665 | |||
2666 | /** | ||
2667 | * In case we receive an EPG packet before mpegts context is fully | ||
2668 | * initialized. | ||
2669 | */ | ||
2670 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 12 times.
|
12 | if (!ts->pkt) |
2671 | ✗ | return; | |
2672 | |||
2673 | 12 | new_data_packet(section, section_len, ts->pkt); | |
2674 | 12 | ts->pkt->stream_index = ts->epg_stream->index; | |
2675 | 12 | ts->stop_parse = 1; | |
2676 | } | ||
2677 | |||
2678 | 442 | static void sdt_cb(MpegTSFilter *filter, const uint8_t *section, int section_len) | |
2679 | { | ||
2680 | 442 | MpegTSContext *ts = filter->u.section_filter.opaque; | |
2681 | 442 | MpegTSSectionFilter *tssf = &filter->u.section_filter; | |
2682 | 442 | SectionHeader h1, *h = &h1; | |
2683 | const uint8_t *p, *p_end, *desc_list_end, *desc_end; | ||
2684 | int onid, val, sid, desc_list_len, desc_tag, desc_len, service_type; | ||
2685 | char *name, *provider_name; | ||
2686 | |||
2687 | 442 | av_log(ts->stream, AV_LOG_TRACE, "SDT:\n"); | |
2688 | hex_dump_debug(ts->stream, section, section_len); | ||
2689 | |||
2690 | 442 | p_end = section + section_len - 4; | |
2691 | 442 | p = section; | |
2692 |
1/2✗ Branch 1 not taken.
✓ Branch 2 taken 442 times.
|
442 | if (parse_section_header(h, &p, p_end) < 0) |
2693 | 342 | return; | |
2694 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 442 times.
|
442 | if (h->tid != SDT_TID) |
2695 | ✗ | return; | |
2696 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 442 times.
|
442 | if (!h->current_next) |
2697 | ✗ | return; | |
2698 |
2/2✓ Branch 0 taken 55 times.
✓ Branch 1 taken 387 times.
|
442 | if (ts->skip_changes) |
2699 | 55 | return; | |
2700 |
2/2✓ Branch 1 taken 287 times.
✓ Branch 2 taken 100 times.
|
387 | if (skip_identical(h, tssf)) |
2701 | 287 | return; | |
2702 | |||
2703 | 100 | onid = get16(&p, p_end); | |
2704 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 100 times.
|
100 | if (onid < 0) |
2705 | ✗ | return; | |
2706 | 100 | val = get8(&p, p_end); | |
2707 |
1/2✓ Branch 0 taken 100 times.
✗ Branch 1 not taken.
|
100 | if (val < 0) |
2708 | ✗ | return; | |
2709 | for (;;) { | ||
2710 | 200 | sid = get16(&p, p_end); | |
2711 |
2/2✓ Branch 0 taken 100 times.
✓ Branch 1 taken 100 times.
|
200 | if (sid < 0) |
2712 | 100 | break; | |
2713 | 100 | val = get8(&p, p_end); | |
2714 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 100 times.
|
100 | if (val < 0) |
2715 | ✗ | break; | |
2716 | 100 | desc_list_len = get16(&p, p_end); | |
2717 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 100 times.
|
100 | if (desc_list_len < 0) |
2718 | ✗ | break; | |
2719 | 100 | desc_list_len &= 0xfff; | |
2720 | 100 | desc_list_end = p + desc_list_len; | |
2721 |
1/2✓ Branch 0 taken 100 times.
✗ Branch 1 not taken.
|
100 | if (desc_list_end > p_end) |
2722 | ✗ | break; | |
2723 | for (;;) { | ||
2724 | 200 | desc_tag = get8(&p, desc_list_end); | |
2725 |
2/2✓ Branch 0 taken 100 times.
✓ Branch 1 taken 100 times.
|
200 | if (desc_tag < 0) |
2726 | 100 | break; | |
2727 | 100 | desc_len = get8(&p, desc_list_end); | |
2728 | 100 | desc_end = p + desc_len; | |
2729 |
2/4✓ Branch 0 taken 100 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 100 times.
✗ Branch 3 not taken.
|
100 | if (desc_len < 0 || desc_end > desc_list_end) |
2730 | break; | ||
2731 | |||
2732 | 100 | av_log(ts->stream, AV_LOG_TRACE, "tag: 0x%02x len=%d\n", | |
2733 | desc_tag, desc_len); | ||
2734 | |||
2735 |
1/2✓ Branch 0 taken 100 times.
✗ Branch 1 not taken.
|
100 | switch (desc_tag) { |
2736 | 100 | case 0x48: | |
2737 | 100 | service_type = get8(&p, desc_end); | |
2738 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 100 times.
|
100 | if (service_type < 0) |
2739 | ✗ | break; | |
2740 | 100 | provider_name = getstr8(&p, desc_end); | |
2741 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 100 times.
|
100 | if (!provider_name) |
2742 | ✗ | break; | |
2743 | 100 | name = getstr8(&p, desc_end); | |
2744 |
1/2✓ Branch 0 taken 100 times.
✗ Branch 1 not taken.
|
100 | if (name) { |
2745 | 100 | AVProgram *program = av_new_program(ts->stream, sid); | |
2746 |
1/2✓ Branch 0 taken 100 times.
✗ Branch 1 not taken.
|
100 | if (program) { |
2747 | 100 | av_dict_set(&program->metadata, "service_name", name, 0); | |
2748 | 100 | av_dict_set(&program->metadata, "service_provider", | |
2749 | provider_name, 0); | ||
2750 | } | ||
2751 | } | ||
2752 | 100 | av_free(name); | |
2753 | 100 | av_free(provider_name); | |
2754 | 100 | break; | |
2755 | ✗ | default: | |
2756 | ✗ | break; | |
2757 | } | ||
2758 | 100 | p = desc_end; | |
2759 | } | ||
2760 | 100 | p = desc_list_end; | |
2761 | } | ||
2762 | } | ||
2763 | |||
2764 | static int parse_pcr(int64_t *ppcr_high, int *ppcr_low, | ||
2765 | const uint8_t *packet); | ||
2766 | |||
2767 | /* handle one TS packet */ | ||
2768 | 389728 | static int handle_packet(MpegTSContext *ts, const uint8_t *packet, int64_t pos) | |
2769 | { | ||
2770 | MpegTSFilter *tss; | ||
2771 | int len, pid, cc, expected_cc, cc_ok, afc, is_start, is_discontinuity, | ||
2772 | has_adaptation, has_payload; | ||
2773 | const uint8_t *p, *p_end; | ||
2774 | |||
2775 | 389728 | pid = AV_RB16(packet + 1) & 0x1fff; | |
2776 | 389728 | is_start = packet[1] & 0x40; | |
2777 | 389728 | tss = ts->pids[pid]; | |
2778 |
6/6✓ Branch 0 taken 382300 times.
✓ Branch 1 taken 7428 times.
✓ Branch 2 taken 6592 times.
✓ Branch 3 taken 375708 times.
✓ Branch 4 taken 17 times.
✓ Branch 5 taken 6575 times.
|
389728 | if (ts->auto_guess && !tss && is_start) { |
2779 | 17 | add_pes_stream(ts, pid, -1); | |
2780 | 17 | tss = ts->pids[pid]; | |
2781 | } | ||
2782 |
2/2✓ Branch 0 taken 13865 times.
✓ Branch 1 taken 375863 times.
|
389728 | if (!tss) |
2783 | 13865 | return 0; | |
2784 |
2/2✓ Branch 0 taken 35875 times.
✓ Branch 1 taken 339988 times.
|
375863 | if (is_start) |
2785 | 35875 | tss->discard = discard_pid(ts, pid); | |
2786 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 375863 times.
|
375863 | if (tss->discard) |
2787 | ✗ | return 0; | |
2788 | 375863 | ts->current_pid = pid; | |
2789 | |||
2790 | 375863 | afc = (packet[3] >> 4) & 3; | |
2791 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 375863 times.
|
375863 | if (afc == 0) /* reserved value */ |
2792 | ✗ | return 0; | |
2793 | 375863 | has_adaptation = afc & 2; | |
2794 | 375863 | has_payload = afc & 1; | |
2795 | 434984 | is_discontinuity = has_adaptation && | |
2796 |
4/4✓ Branch 0 taken 59121 times.
✓ Branch 1 taken 316742 times.
✓ Branch 2 taken 59083 times.
✓ Branch 3 taken 38 times.
|
434946 | packet[4] != 0 && /* with length > 0 */ |
2797 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 59083 times.
|
59083 | (packet[5] & 0x80); /* and discontinuity indicated */ |
2798 | |||
2799 | /* continuity check (currently not used) */ | ||
2800 | 375863 | cc = (packet[3] & 0xf); | |
2801 |
2/2✓ Branch 0 taken 373059 times.
✓ Branch 1 taken 2804 times.
|
375863 | expected_cc = has_payload ? (tss->last_cc + 1) & 0x0f : tss->last_cc; |
2802 |
1/2✓ Branch 0 taken 375863 times.
✗ Branch 1 not taken.
|
375863 | cc_ok = pid == 0x1FFF || // null packet PID |
2803 | 375863 | is_discontinuity || | |
2804 |
5/6✓ Branch 0 taken 375863 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 374757 times.
✓ Branch 3 taken 1106 times.
✓ Branch 4 taken 374109 times.
✓ Branch 5 taken 648 times.
|
751726 | tss->last_cc < 0 || |
2805 | expected_cc == cc; | ||
2806 | |||
2807 | 375863 | tss->last_cc = cc; | |
2808 |
2/2✓ Branch 0 taken 648 times.
✓ Branch 1 taken 375215 times.
|
375863 | if (!cc_ok) { |
2809 | 648 | av_log(ts->stream, AV_LOG_DEBUG, | |
2810 | "Continuity check failed for pid %d expected %d got %d\n", | ||
2811 | pid, expected_cc, cc); | ||
2812 |
2/2✓ Branch 0 taken 7 times.
✓ Branch 1 taken 641 times.
|
648 | if (tss->type == MPEGTS_PES) { |
2813 | 7 | PESContext *pc = tss->u.pes_filter.opaque; | |
2814 | 7 | pc->flags |= AV_PKT_FLAG_CORRUPT; | |
2815 | } | ||
2816 | } | ||
2817 | |||
2818 |
2/2✓ Branch 0 taken 12 times.
✓ Branch 1 taken 375851 times.
|
375863 | if (packet[1] & 0x80) { |
2819 | 12 | av_log(ts->stream, AV_LOG_DEBUG, "Packet had TEI flag set; marking as corrupt\n"); | |
2820 |
1/2✓ Branch 0 taken 12 times.
✗ Branch 1 not taken.
|
12 | if (tss->type == MPEGTS_PES) { |
2821 | 12 | PESContext *pc = tss->u.pes_filter.opaque; | |
2822 | 12 | pc->flags |= AV_PKT_FLAG_CORRUPT; | |
2823 | } | ||
2824 | } | ||
2825 | |||
2826 | 375863 | p = packet + 4; | |
2827 |
2/2✓ Branch 0 taken 59121 times.
✓ Branch 1 taken 316742 times.
|
375863 | if (has_adaptation) { |
2828 | int64_t pcr_h; | ||
2829 | int pcr_l; | ||
2830 |
2/2✓ Branch 1 taken 27402 times.
✓ Branch 2 taken 31719 times.
|
59121 | if (parse_pcr(&pcr_h, &pcr_l, packet) == 0) |
2831 | 27402 | tss->last_pcr = pcr_h * 300 + pcr_l; | |
2832 | /* skip adaptation field */ | ||
2833 | 59121 | p += p[0] + 1; | |
2834 | } | ||
2835 | /* if past the end of packet, ignore */ | ||
2836 | 375863 | p_end = packet + TS_PACKET_SIZE; | |
2837 |
3/4✓ Branch 0 taken 373047 times.
✓ Branch 1 taken 2816 times.
✗ Branch 2 not taken.
✓ Branch 3 taken 373047 times.
|
375863 | if (p >= p_end || !has_payload) |
2838 | 2816 | return 0; | |
2839 | |||
2840 |
1/2✓ Branch 0 taken 373047 times.
✗ Branch 1 not taken.
|
373047 | if (pos >= 0) { |
2841 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 373047 times.
|
373047 | av_assert0(pos >= TS_PACKET_SIZE); |
2842 | 373047 | ts->pos47_full = pos - TS_PACKET_SIZE; | |
2843 | } | ||
2844 | |||
2845 |
2/2✓ Branch 0 taken 6406 times.
✓ Branch 1 taken 366641 times.
|
373047 | if (tss->type == MPEGTS_SECTION) { |
2846 |
2/2✓ Branch 0 taken 6371 times.
✓ Branch 1 taken 35 times.
|
6406 | if (is_start) { |
2847 | /* pointer field present */ | ||
2848 | 6371 | len = *p++; | |
2849 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 6371 times.
|
6371 | if (len > p_end - p) |
2850 | ✗ | return 0; | |
2851 |
1/4✗ Branch 0 not taken.
✓ Branch 1 taken 6371 times.
✗ Branch 2 not taken.
✗ Branch 3 not taken.
|
6371 | if (len && cc_ok) { |
2852 | /* write remaining section bytes */ | ||
2853 | ✗ | write_section_data(ts, tss, | |
2854 | p, len, 0); | ||
2855 | /* check whether filter has been closed */ | ||
2856 | ✗ | if (!ts->pids[pid]) | |
2857 | ✗ | return 0; | |
2858 | } | ||
2859 | 6371 | p += len; | |
2860 |
1/2✓ Branch 0 taken 6371 times.
✗ Branch 1 not taken.
|
6371 | if (p < p_end) { |
2861 | 6371 | write_section_data(ts, tss, | |
2862 | 6371 | p, p_end - p, 1); | |
2863 | } | ||
2864 | } else { | ||
2865 |
1/2✓ Branch 0 taken 35 times.
✗ Branch 1 not taken.
|
35 | if (cc_ok) { |
2866 | 35 | write_section_data(ts, tss, | |
2867 | 35 | p, p_end - p, 0); | |
2868 | } | ||
2869 | } | ||
2870 | |||
2871 | // stop find_stream_info from waiting for more streams | ||
2872 | // when all programs have received a PMT | ||
2873 |
4/4✓ Branch 0 taken 4366 times.
✓ Branch 1 taken 2040 times.
✓ Branch 2 taken 17 times.
✓ Branch 3 taken 4349 times.
|
6406 | if (ts->stream->ctx_flags & AVFMTCTX_NOHEADER && ts->scan_all_pmts <= 0) { |
2874 | int i; | ||
2875 |
2/2✓ Branch 0 taken 17 times.
✓ Branch 1 taken 17 times.
|
34 | for (i = 0; i < ts->nb_prg; i++) { |
2876 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 17 times.
|
17 | if (!ts->prg[i].pmt_found) |
2877 | ✗ | break; | |
2878 | } | ||
2879 |
2/4✓ Branch 0 taken 17 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 17 times.
✗ Branch 3 not taken.
|
17 | if (i == ts->nb_prg && ts->nb_prg > 0) { |
2880 | 17 | av_log(ts->stream, AV_LOG_DEBUG, "All programs have pmt, headers found\n"); | |
2881 | 17 | ts->stream->ctx_flags &= ~AVFMTCTX_NOHEADER; | |
2882 | } | ||
2883 | } | ||
2884 | |||
2885 | } else { | ||
2886 | int ret; | ||
2887 | // Note: The position here points actually behind the current packet. | ||
2888 |
1/2✓ Branch 0 taken 366641 times.
✗ Branch 1 not taken.
|
366641 | if (tss->type == MPEGTS_PES) { |
2889 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 366641 times.
|
366641 | if ((ret = tss->u.pes_filter.pes_cb(tss, p, p_end - p, is_start, |
2890 | 366641 | pos - ts->raw_packet_size)) < 0) | |
2891 | ✗ | return ret; | |
2892 | } | ||
2893 | } | ||
2894 | |||
2895 | 373047 | return 0; | |
2896 | } | ||
2897 | |||
2898 | 58 | static int mpegts_resync(AVFormatContext *s, int seekback, const uint8_t *current_packet) | |
2899 | { | ||
2900 | 58 | MpegTSContext *ts = s->priv_data; | |
2901 | 58 | AVIOContext *pb = s->pb; | |
2902 | int c, i; | ||
2903 | 58 | uint64_t pos = avio_tell(pb); | |
2904 | 58 | int64_t back = FFMIN(seekback, pos); | |
2905 | |||
2906 | //Special case for files like 01c56b0dc1.ts | ||
2907 |
3/6✓ Branch 0 taken 6 times.
✓ Branch 1 taken 52 times.
✗ Branch 2 not taken.
✓ Branch 3 taken 6 times.
✗ Branch 4 not taken.
✗ Branch 5 not taken.
|
58 | if (current_packet[0] == 0x80 && current_packet[12] == 0x47 && pos >= TS_PACKET_SIZE) { |
2908 | ✗ | avio_seek(pb, 12 - TS_PACKET_SIZE, SEEK_CUR); | |
2909 | ✗ | return 0; | |
2910 | } | ||
2911 | |||
2912 | 58 | avio_seek(pb, -back, SEEK_CUR); | |
2913 | |||
2914 |
1/2✓ Branch 0 taken 4108 times.
✗ Branch 1 not taken.
|
4108 | for (i = 0; i < ts->resync_size; i++) { |
2915 | 4108 | c = avio_r8(pb); | |
2916 |
1/2✗ Branch 1 not taken.
✓ Branch 2 taken 4108 times.
|
4108 | if (avio_feof(pb)) |
2917 | ✗ | return AVERROR_EOF; | |
2918 |
2/2✓ Branch 0 taken 58 times.
✓ Branch 1 taken 4050 times.
|
4108 | if (c == 0x47) { |
2919 | int new_packet_size, ret; | ||
2920 | 58 | avio_seek(pb, -1, SEEK_CUR); | |
2921 | 58 | pos = avio_tell(pb); | |
2922 | 58 | ret = ffio_ensure_seekback(pb, PROBE_PACKET_MAX_BUF); | |
2923 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 58 times.
|
58 | if (ret < 0) |
2924 | ✗ | return ret; | |
2925 | 58 | new_packet_size = get_packet_size(s); | |
2926 |
2/4✓ Branch 0 taken 58 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 58 times.
|
58 | if (new_packet_size > 0 && new_packet_size != ts->raw_packet_size) { |
2927 | ✗ | av_log(ts->stream, AV_LOG_WARNING, "changing packet size to %d\n", new_packet_size); | |
2928 | ✗ | ts->raw_packet_size = new_packet_size; | |
2929 | } | ||
2930 | 58 | avio_seek(pb, pos, SEEK_SET); | |
2931 | 58 | return 0; | |
2932 | } | ||
2933 | } | ||
2934 | ✗ | av_log(s, AV_LOG_ERROR, | |
2935 | "max resync size reached, could not find sync byte\n"); | ||
2936 | /* no sync found */ | ||
2937 | ✗ | return AVERROR_INVALIDDATA; | |
2938 | } | ||
2939 | |||
2940 | /* return AVERROR_something if error or EOF. Return 0 if OK. */ | ||
2941 | 390079 | static int read_packet(AVFormatContext *s, uint8_t *buf, int raw_packet_size, | |
2942 | const uint8_t **data) | ||
2943 | { | ||
2944 | 390079 | AVIOContext *pb = s->pb; | |
2945 | int len; | ||
2946 | |||
2947 | for (;;) { | ||
2948 | 390137 | len = ffio_read_indirect(pb, buf, TS_PACKET_SIZE, data); | |
2949 |
2/2✓ Branch 0 taken 351 times.
✓ Branch 1 taken 389786 times.
|
390137 | if (len != TS_PACKET_SIZE) |
2950 |
2/2✓ Branch 0 taken 296 times.
✓ Branch 1 taken 55 times.
|
351 | return len < 0 ? len : AVERROR_EOF; |
2951 | /* check packet sync byte */ | ||
2952 |
2/2✓ Branch 0 taken 58 times.
✓ Branch 1 taken 389728 times.
|
389786 | if ((*data)[0] != 0x47) { |
2953 | /* find a new packet start */ | ||
2954 | |||
2955 |
1/2✗ Branch 1 not taken.
✓ Branch 2 taken 58 times.
|
58 | if (mpegts_resync(s, raw_packet_size, *data) < 0) |
2956 | ✗ | return AVERROR(EAGAIN); | |
2957 | else | ||
2958 | 58 | continue; | |
2959 | } else { | ||
2960 | 389728 | break; | |
2961 | } | ||
2962 | } | ||
2963 | 389728 | return 0; | |
2964 | } | ||
2965 | |||
2966 | 389728 | static void finished_reading_packet(AVFormatContext *s, int raw_packet_size) | |
2967 | { | ||
2968 | 389728 | AVIOContext *pb = s->pb; | |
2969 | 389728 | int skip = raw_packet_size - TS_PACKET_SIZE; | |
2970 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 389728 times.
|
389728 | if (skip > 0) |
2971 | ✗ | avio_skip(pb, skip); | |
2972 | 389728 | } | |
2973 | |||
2974 | 29072 | static int handle_packets(MpegTSContext *ts, int64_t nb_packets) | |
2975 | { | ||
2976 | 29072 | AVFormatContext *s = ts->stream; | |
2977 | uint8_t packet[TS_PACKET_SIZE + AV_INPUT_BUFFER_PADDING_SIZE]; | ||
2978 | const uint8_t *data; | ||
2979 | int64_t packet_num; | ||
2980 | 29072 | int ret = 0; | |
2981 | |||
2982 |
2/2✓ Branch 1 taken 256 times.
✓ Branch 2 taken 28816 times.
|
29072 | if (avio_tell(s->pb) != ts->last_pos) { |
2983 | int i; | ||
2984 | 256 | av_log(ts->stream, AV_LOG_TRACE, "Skipping after seek\n"); | |
2985 | /* seek detected, flush pes buffer */ | ||
2986 |
2/2✓ Branch 0 taken 2097152 times.
✓ Branch 1 taken 256 times.
|
2097408 | for (i = 0; i < NB_PID_MAX; i++) { |
2987 |
2/2✓ Branch 0 taken 1572 times.
✓ Branch 1 taken 2095580 times.
|
2097152 | if (ts->pids[i]) { |
2988 |
2/2✓ Branch 0 taken 531 times.
✓ Branch 1 taken 1041 times.
|
1572 | if (ts->pids[i]->type == MPEGTS_PES) { |
2989 | 531 | PESContext *pes = ts->pids[i]->u.pes_filter.opaque; | |
2990 | 531 | av_buffer_unref(&pes->buffer); | |
2991 | 531 | pes->data_index = 0; | |
2992 | 531 | pes->state = MPEGTS_SKIP; /* skip until pes header */ | |
2993 |
1/2✓ Branch 0 taken 1041 times.
✗ Branch 1 not taken.
|
1041 | } else if (ts->pids[i]->type == MPEGTS_SECTION) { |
2994 | 1041 | ts->pids[i]->u.section_filter.last_ver = -1; | |
2995 | } | ||
2996 | 1572 | ts->pids[i]->last_cc = -1; | |
2997 | 1572 | ts->pids[i]->last_pcr = -1; | |
2998 | } | ||
2999 | } | ||
3000 | } | ||
3001 | |||
3002 | 29072 | ts->stop_parse = 0; | |
3003 | 29072 | packet_num = 0; | |
3004 | 29072 | memset(packet + TS_PACKET_SIZE, 0, AV_INPUT_BUFFER_PADDING_SIZE); | |
3005 | for (;;) { | ||
3006 | 418800 | packet_num++; | |
3007 |
3/4✓ Branch 0 taken 7482 times.
✓ Branch 1 taken 411318 times.
✓ Branch 2 taken 7482 times.
✗ Branch 3 not taken.
|
418800 | if (nb_packets != 0 && packet_num >= nb_packets || |
3008 |
2/2✓ Branch 0 taken 54 times.
✓ Branch 1 taken 418746 times.
|
418800 | ts->stop_parse > 1) { |
3009 | 54 | ret = AVERROR(EAGAIN); | |
3010 | 54 | break; | |
3011 | } | ||
3012 |
2/2✓ Branch 0 taken 28667 times.
✓ Branch 1 taken 390079 times.
|
418746 | if (ts->stop_parse > 0) |
3013 | 28667 | break; | |
3014 | |||
3015 | 390079 | ret = read_packet(s, packet, ts->raw_packet_size, &data); | |
3016 |
2/2✓ Branch 0 taken 351 times.
✓ Branch 1 taken 389728 times.
|
390079 | if (ret != 0) |
3017 | 351 | break; | |
3018 | 389728 | ret = handle_packet(ts, data, avio_tell(s->pb)); | |
3019 | 389728 | finished_reading_packet(s, ts->raw_packet_size); | |
3020 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 389728 times.
|
389728 | if (ret != 0) |
3021 | ✗ | break; | |
3022 | } | ||
3023 | 29072 | ts->last_pos = avio_tell(s->pb); | |
3024 | 29072 | return ret; | |
3025 | } | ||
3026 | |||
3027 | 7148 | static int mpegts_probe(const AVProbeData *p) | |
3028 | { | ||
3029 | 7148 | const int size = p->buf_size; | |
3030 | 7148 | int maxscore = 0; | |
3031 | 7148 | int sumscore = 0; | |
3032 | int i; | ||
3033 | 7148 | int check_count = size / TS_FEC_PACKET_SIZE; | |
3034 | #define CHECK_COUNT 10 | ||
3035 | #define CHECK_BLOCK 100 | ||
3036 | |||
3037 |
2/2✓ Branch 0 taken 13 times.
✓ Branch 1 taken 7135 times.
|
7148 | if (!check_count) |
3038 | 13 | return 0; | |
3039 | |||
3040 |
2/2✓ Branch 0 taken 23094 times.
✓ Branch 1 taken 7135 times.
|
30229 | for (i = 0; i<check_count; i+=CHECK_BLOCK) { |
3041 | 23094 | int left = FFMIN(check_count - i, CHECK_BLOCK); | |
3042 | 23094 | int score = analyze(p->buf + TS_PACKET_SIZE *i, TS_PACKET_SIZE *left, TS_PACKET_SIZE , 1); | |
3043 | 23094 | int dvhs_score = analyze(p->buf + TS_DVHS_PACKET_SIZE*i, TS_DVHS_PACKET_SIZE*left, TS_DVHS_PACKET_SIZE, 1); | |
3044 | 23094 | int fec_score = analyze(p->buf + TS_FEC_PACKET_SIZE *i, TS_FEC_PACKET_SIZE *left, TS_FEC_PACKET_SIZE , 1); | |
3045 | 23094 | score = FFMAX3(score, dvhs_score, fec_score); | |
3046 | 23094 | sumscore += score; | |
3047 | 23094 | maxscore = FFMAX(maxscore, score); | |
3048 | } | ||
3049 | |||
3050 | 7135 | sumscore = sumscore * CHECK_COUNT / check_count; | |
3051 | 7135 | maxscore = maxscore * CHECK_COUNT / CHECK_BLOCK; | |
3052 | |||
3053 | ff_dlog(0, "TS score: %d %d\n", sumscore, maxscore); | ||
3054 | |||
3055 |
3/4✓ Branch 0 taken 3194 times.
✓ Branch 1 taken 3941 times.
✗ Branch 2 not taken.
✓ Branch 3 taken 3194 times.
|
7135 | if (check_count > CHECK_COUNT && sumscore > 6) { |
3056 | ✗ | return AVPROBE_SCORE_MAX + sumscore - CHECK_COUNT; | |
3057 |
4/4✓ Branch 0 taken 6781 times.
✓ Branch 1 taken 354 times.
✓ Branch 2 taken 46 times.
✓ Branch 3 taken 6735 times.
|
7135 | } else if (check_count >= CHECK_COUNT && sumscore > 6) { |
3058 | 46 | return AVPROBE_SCORE_MAX/2 + sumscore - CHECK_COUNT; | |
3059 |
3/4✓ Branch 0 taken 6735 times.
✓ Branch 1 taken 354 times.
✗ Branch 2 not taken.
✓ Branch 3 taken 6735 times.
|
7089 | } else if (check_count >= CHECK_COUNT && maxscore > 6) { |
3060 | ✗ | return AVPROBE_SCORE_MAX/2 + sumscore - CHECK_COUNT; | |
3061 |
2/2✓ Branch 0 taken 5 times.
✓ Branch 1 taken 7084 times.
|
7089 | } else if (sumscore > 6) { |
3062 | 5 | return 2; | |
3063 | } else { | ||
3064 | 7084 | return 0; | |
3065 | } | ||
3066 | } | ||
3067 | |||
3068 | /* return the 90kHz PCR and the extension for the 27MHz PCR. return | ||
3069 | * (-1) if not available */ | ||
3070 | 59121 | static int parse_pcr(int64_t *ppcr_high, int *ppcr_low, const uint8_t *packet) | |
3071 | { | ||
3072 | int afc, len, flags; | ||
3073 | const uint8_t *p; | ||
3074 | unsigned int v; | ||
3075 | |||
3076 | 59121 | afc = (packet[3] >> 4) & 3; | |
3077 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 59121 times.
|
59121 | if (afc <= 1) |
3078 | ✗ | return AVERROR_INVALIDDATA; | |
3079 | 59121 | p = packet + 4; | |
3080 | 59121 | len = p[0]; | |
3081 | 59121 | p++; | |
3082 |
2/2✓ Branch 0 taken 38 times.
✓ Branch 1 taken 59083 times.
|
59121 | if (len == 0) |
3083 | 38 | return AVERROR_INVALIDDATA; | |
3084 | 59083 | flags = *p++; | |
3085 | 59083 | len--; | |
3086 |
2/2✓ Branch 0 taken 31681 times.
✓ Branch 1 taken 27402 times.
|
59083 | if (!(flags & 0x10)) |
3087 | 31681 | return AVERROR_INVALIDDATA; | |
3088 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 27402 times.
|
27402 | if (len < 6) |
3089 | ✗ | return AVERROR_INVALIDDATA; | |
3090 | 27402 | v = AV_RB32(p); | |
3091 | 27402 | *ppcr_high = ((int64_t) v << 1) | (p[4] >> 7); | |
3092 | 27402 | *ppcr_low = ((p[4] & 1) << 8) | p[5]; | |
3093 | 27402 | return 0; | |
3094 | } | ||
3095 | |||
3096 | 108 | static void seek_back(AVFormatContext *s, AVIOContext *pb, int64_t pos) { | |
3097 | |||
3098 | /* NOTE: We attempt to seek on non-seekable files as well, as the | ||
3099 | * probe buffer usually is big enough. Only warn if the seek failed | ||
3100 | * on files where the seek should work. */ | ||
3101 |
1/2✗ Branch 1 not taken.
✓ Branch 2 taken 108 times.
|
108 | if (avio_seek(pb, pos, SEEK_SET) < 0) |
3102 | ✗ | av_log(s, (pb->seekable & AVIO_SEEKABLE_NORMAL) ? AV_LOG_ERROR : AV_LOG_INFO, "Unable to seek back to the start\n"); | |
3103 | 108 | } | |
3104 | |||
3105 | 54 | static int mpegts_read_header(AVFormatContext *s) | |
3106 | { | ||
3107 | 54 | MpegTSContext *ts = s->priv_data; | |
3108 | 54 | AVIOContext *pb = s->pb; | |
3109 | 54 | int64_t pos, probesize = s->probesize; | |
3110 | 54 | int64_t seekback = FFMAX(s->probesize, (int64_t)ts->resync_size + PROBE_PACKET_MAX_BUF); | |
3111 | |||
3112 | 54 | ffformatcontext(s)->prefer_codec_framerate = 1; | |
3113 | |||
3114 |
1/2✗ Branch 1 not taken.
✓ Branch 2 taken 54 times.
|
54 | if (ffio_ensure_seekback(pb, seekback) < 0) |
3115 | ✗ | av_log(s, AV_LOG_WARNING, "Failed to allocate buffers for seekback\n"); | |
3116 | |||
3117 | 54 | pos = avio_tell(pb); | |
3118 | 54 | ts->raw_packet_size = get_packet_size(s); | |
3119 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 54 times.
|
54 | if (ts->raw_packet_size <= 0) { |
3120 | ✗ | av_log(s, AV_LOG_WARNING, "Could not detect TS packet size, defaulting to non-FEC/DVHS\n"); | |
3121 | ✗ | ts->raw_packet_size = TS_PACKET_SIZE; | |
3122 | } | ||
3123 | 54 | ts->stream = s; | |
3124 | 54 | ts->auto_guess = 0; | |
3125 | |||
3126 |
1/2✓ Branch 0 taken 54 times.
✗ Branch 1 not taken.
|
54 | if (s->iformat == &ff_mpegts_demuxer.p) { |
3127 | /* normal demux */ | ||
3128 | |||
3129 | /* first do a scan to get all the services */ | ||
3130 | 54 | seek_back(s, pb, pos); | |
3131 | |||
3132 | 54 | mpegts_open_section_filter(ts, SDT_PID, sdt_cb, ts, 1); | |
3133 | 54 | mpegts_open_section_filter(ts, PAT_PID, pat_cb, ts, 1); | |
3134 | 54 | mpegts_open_section_filter(ts, EIT_PID, eit_cb, ts, 1); | |
3135 | |||
3136 | 54 | handle_packets(ts, probesize / ts->raw_packet_size); | |
3137 | /* if could not find service, enable auto_guess */ | ||
3138 | |||
3139 | 54 | ts->auto_guess = 1; | |
3140 | |||
3141 | 54 | av_log(ts->stream, AV_LOG_TRACE, "tuning done\n"); | |
3142 | |||
3143 | 54 | s->ctx_flags |= AVFMTCTX_NOHEADER; | |
3144 | } else { | ||
3145 | AVStream *st; | ||
3146 | int pcr_pid, pid, nb_packets, nb_pcrs, ret, pcr_l; | ||
3147 | int64_t pcrs[2], pcr_h; | ||
3148 | uint8_t packet[TS_PACKET_SIZE]; | ||
3149 | const uint8_t *data; | ||
3150 | |||
3151 | /* only read packets */ | ||
3152 | |||
3153 | ✗ | st = avformat_new_stream(s, NULL); | |
3154 | ✗ | if (!st) | |
3155 | ✗ | return AVERROR(ENOMEM); | |
3156 | ✗ | avpriv_set_pts_info(st, 60, 1, 27000000); | |
3157 | ✗ | st->codecpar->codec_type = AVMEDIA_TYPE_DATA; | |
3158 | ✗ | st->codecpar->codec_id = AV_CODEC_ID_MPEG2TS; | |
3159 | |||
3160 | /* we iterate until we find two PCRs to estimate the bitrate */ | ||
3161 | ✗ | pcr_pid = -1; | |
3162 | ✗ | nb_pcrs = 0; | |
3163 | ✗ | nb_packets = 0; | |
3164 | for (;;) { | ||
3165 | ✗ | ret = read_packet(s, packet, ts->raw_packet_size, &data); | |
3166 | ✗ | if (ret < 0) | |
3167 | ✗ | return ret; | |
3168 | ✗ | pid = AV_RB16(data + 1) & 0x1fff; | |
3169 | ✗ | if ((pcr_pid == -1 || pcr_pid == pid) && | |
3170 | ✗ | parse_pcr(&pcr_h, &pcr_l, data) == 0) { | |
3171 | ✗ | finished_reading_packet(s, ts->raw_packet_size); | |
3172 | ✗ | pcr_pid = pid; | |
3173 | ✗ | pcrs[nb_pcrs] = pcr_h * 300 + pcr_l; | |
3174 | ✗ | nb_pcrs++; | |
3175 | ✗ | if (nb_pcrs >= 2) { | |
3176 | ✗ | if (pcrs[1] - pcrs[0] > 0) { | |
3177 | /* the difference needs to be positive to make sense for bitrate computation */ | ||
3178 | ✗ | break; | |
3179 | } else { | ||
3180 | ✗ | av_log(ts->stream, AV_LOG_WARNING, "invalid pcr pair %"PRId64" >= %"PRId64"\n", pcrs[0], pcrs[1]); | |
3181 | ✗ | pcrs[0] = pcrs[1]; | |
3182 | ✗ | nb_pcrs--; | |
3183 | } | ||
3184 | } | ||
3185 | } else { | ||
3186 | ✗ | finished_reading_packet(s, ts->raw_packet_size); | |
3187 | } | ||
3188 | ✗ | nb_packets++; | |
3189 | } | ||
3190 | |||
3191 | /* NOTE1: the bitrate is computed without the FEC */ | ||
3192 | /* NOTE2: it is only the bitrate of the start of the stream */ | ||
3193 | ✗ | ts->pcr_incr = pcrs[1] - pcrs[0]; | |
3194 | ✗ | ts->cur_pcr = pcrs[0] - ts->pcr_incr * (nb_packets - 1); | |
3195 | ✗ | s->bit_rate = TS_PACKET_SIZE * 8 * 27000000LL / ts->pcr_incr; | |
3196 | ✗ | st->codecpar->bit_rate = s->bit_rate; | |
3197 | ✗ | st->start_time = ts->cur_pcr; | |
3198 | ✗ | av_log(ts->stream, AV_LOG_TRACE, "start=%0.3f pcr=%0.3f incr=%"PRId64"\n", | |
3199 | ✗ | st->start_time / 1000000.0, pcrs[0] / 27e6, ts->pcr_incr); | |
3200 | } | ||
3201 | |||
3202 | 54 | seek_back(s, pb, pos); | |
3203 | 54 | return 0; | |
3204 | } | ||
3205 | |||
3206 | #define MAX_PACKET_READAHEAD ((128 * 1024) / 188) | ||
3207 | |||
3208 | ✗ | static int mpegts_raw_read_packet(AVFormatContext *s, AVPacket *pkt) | |
3209 | { | ||
3210 | ✗ | MpegTSContext *ts = s->priv_data; | |
3211 | int ret, i; | ||
3212 | int64_t pcr_h, next_pcr_h, pos; | ||
3213 | int pcr_l, next_pcr_l; | ||
3214 | uint8_t pcr_buf[12]; | ||
3215 | const uint8_t *data; | ||
3216 | |||
3217 | ✗ | if ((ret = av_new_packet(pkt, TS_PACKET_SIZE)) < 0) | |
3218 | ✗ | return ret; | |
3219 | ✗ | ret = read_packet(s, pkt->data, ts->raw_packet_size, &data); | |
3220 | ✗ | pkt->pos = avio_tell(s->pb); | |
3221 | ✗ | if (ret < 0) { | |
3222 | ✗ | return ret; | |
3223 | } | ||
3224 | ✗ | if (data != pkt->data) | |
3225 | ✗ | memcpy(pkt->data, data, TS_PACKET_SIZE); | |
3226 | ✗ | finished_reading_packet(s, ts->raw_packet_size); | |
3227 | ✗ | if (ts->mpeg2ts_compute_pcr) { | |
3228 | /* compute exact PCR for each packet */ | ||
3229 | ✗ | if (parse_pcr(&pcr_h, &pcr_l, pkt->data) == 0) { | |
3230 | /* we read the next PCR (XXX: optimize it by using a bigger buffer */ | ||
3231 | ✗ | pos = avio_tell(s->pb); | |
3232 | ✗ | for (i = 0; i < MAX_PACKET_READAHEAD; i++) { | |
3233 | ✗ | avio_seek(s->pb, pos + i * ts->raw_packet_size, SEEK_SET); | |
3234 | ✗ | avio_read(s->pb, pcr_buf, 12); | |
3235 | ✗ | if (parse_pcr(&next_pcr_h, &next_pcr_l, pcr_buf) == 0) { | |
3236 | /* XXX: not precise enough */ | ||
3237 | ✗ | ts->pcr_incr = | |
3238 | ✗ | ((next_pcr_h - pcr_h) * 300 + (next_pcr_l - pcr_l)) / | |
3239 | ✗ | (i + 1); | |
3240 | ✗ | break; | |
3241 | } | ||
3242 | } | ||
3243 | ✗ | avio_seek(s->pb, pos, SEEK_SET); | |
3244 | /* no next PCR found: we use previous increment */ | ||
3245 | ✗ | ts->cur_pcr = pcr_h * 300 + pcr_l; | |
3246 | } | ||
3247 | ✗ | pkt->pts = ts->cur_pcr; | |
3248 | ✗ | pkt->duration = ts->pcr_incr; | |
3249 | ✗ | ts->cur_pcr += ts->pcr_incr; | |
3250 | } | ||
3251 | ✗ | pkt->stream_index = 0; | |
3252 | ✗ | return 0; | |
3253 | } | ||
3254 | |||
3255 | 29018 | static int mpegts_read_packet(AVFormatContext *s, AVPacket *pkt) | |
3256 | { | ||
3257 | 29018 | MpegTSContext *ts = s->priv_data; | |
3258 | int ret, i; | ||
3259 | |||
3260 | 29018 | pkt->size = -1; | |
3261 | 29018 | ts->pkt = pkt; | |
3262 | 29018 | ret = handle_packets(ts, 0); | |
3263 |
2/2✓ Branch 0 taken 351 times.
✓ Branch 1 taken 28667 times.
|
29018 | if (ret < 0) { |
3264 | 351 | av_packet_unref(ts->pkt); | |
3265 | /* flush pes data left */ | ||
3266 |
2/2✓ Branch 0 taken 2081084 times.
✓ Branch 1 taken 200 times.
|
2081284 | for (i = 0; i < NB_PID_MAX; i++) |
3267 |
4/4✓ Branch 0 taken 2144 times.
✓ Branch 1 taken 2078940 times.
✓ Branch 2 taken 760 times.
✓ Branch 3 taken 1384 times.
|
2081084 | if (ts->pids[i] && ts->pids[i]->type == MPEGTS_PES) { |
3268 | 760 | PESContext *pes = ts->pids[i]->u.pes_filter.opaque; | |
3269 |
3/4✓ Branch 0 taken 151 times.
✓ Branch 1 taken 609 times.
✓ Branch 2 taken 151 times.
✗ Branch 3 not taken.
|
760 | if (pes->state == MPEGTS_PAYLOAD && pes->data_index > 0) { |
3270 | 151 | ret = new_pes_packet(pes, pkt); | |
3271 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 151 times.
|
151 | if (ret < 0) |
3272 | ✗ | return ret; | |
3273 | 151 | pes->state = MPEGTS_SKIP; | |
3274 | 151 | ret = 0; | |
3275 | 151 | break; | |
3276 | } | ||
3277 | } | ||
3278 | } | ||
3279 | |||
3280 |
3/4✓ Branch 0 taken 28818 times.
✓ Branch 1 taken 200 times.
✗ Branch 2 not taken.
✓ Branch 3 taken 28818 times.
|
29018 | if (!ret && pkt->size < 0) |
3281 | ✗ | ret = AVERROR_INVALIDDATA; | |
3282 | 29018 | return ret; | |
3283 | } | ||
3284 | |||
3285 | 54 | static void mpegts_free(MpegTSContext *ts) | |
3286 | { | ||
3287 | int i; | ||
3288 | |||
3289 | 54 | clear_programs(ts); | |
3290 | |||
3291 |
2/2✓ Branch 0 taken 1728 times.
✓ Branch 1 taken 54 times.
|
1782 | for (i = 0; i < FF_ARRAY_ELEMS(ts->pools); i++) |
3292 | 1728 | av_buffer_pool_uninit(&ts->pools[i]); | |
3293 | |||
3294 |
2/2✓ Branch 0 taken 442368 times.
✓ Branch 1 taken 54 times.
|
442422 | for (i = 0; i < NB_PID_MAX; i++) |
3295 |
2/2✓ Branch 0 taken 339 times.
✓ Branch 1 taken 442029 times.
|
442368 | if (ts->pids[i]) |
3296 | 339 | mpegts_close_filter(ts, ts->pids[i]); | |
3297 | 54 | } | |
3298 | |||
3299 | 54 | static int mpegts_read_close(AVFormatContext *s) | |
3300 | { | ||
3301 | 54 | MpegTSContext *ts = s->priv_data; | |
3302 | 54 | mpegts_free(ts); | |
3303 | 54 | return 0; | |
3304 | } | ||
3305 | |||
3306 | ✗ | static av_unused int64_t mpegts_get_pcr(AVFormatContext *s, int stream_index, | |
3307 | int64_t *ppos, int64_t pos_limit) | ||
3308 | { | ||
3309 | ✗ | MpegTSContext *ts = s->priv_data; | |
3310 | int64_t pos, timestamp; | ||
3311 | uint8_t buf[TS_PACKET_SIZE]; | ||
3312 | ✗ | int pcr_l, pcr_pid = | |
3313 | ✗ | ((PESContext *)s->streams[stream_index]->priv_data)->pcr_pid; | |
3314 | ✗ | int pos47 = ts->pos47_full % ts->raw_packet_size; | |
3315 | ✗ | pos = | |
3316 | ✗ | ((*ppos + ts->raw_packet_size - 1 - pos47) / ts->raw_packet_size) * | |
3317 | ✗ | ts->raw_packet_size + pos47; | |
3318 | ✗ | while(pos < pos_limit) { | |
3319 | ✗ | if (avio_seek(s->pb, pos, SEEK_SET) < 0) | |
3320 | ✗ | return AV_NOPTS_VALUE; | |
3321 | ✗ | if (avio_read(s->pb, buf, TS_PACKET_SIZE) != TS_PACKET_SIZE) | |
3322 | ✗ | return AV_NOPTS_VALUE; | |
3323 | ✗ | if (buf[0] != 0x47) { | |
3324 | ✗ | if (mpegts_resync(s, TS_PACKET_SIZE, buf) < 0) | |
3325 | ✗ | return AV_NOPTS_VALUE; | |
3326 | ✗ | pos = avio_tell(s->pb); | |
3327 | ✗ | continue; | |
3328 | } | ||
3329 | ✗ | if ((pcr_pid < 0 || (AV_RB16(buf + 1) & 0x1fff) == pcr_pid) && | |
3330 | ✗ | parse_pcr(×tamp, &pcr_l, buf) == 0) { | |
3331 | ✗ | *ppos = pos; | |
3332 | ✗ | return timestamp; | |
3333 | } | ||
3334 | ✗ | pos += ts->raw_packet_size; | |
3335 | } | ||
3336 | |||
3337 | ✗ | return AV_NOPTS_VALUE; | |
3338 | } | ||
3339 | |||
3340 | 90 | static int64_t mpegts_get_dts(AVFormatContext *s, int stream_index, | |
3341 | int64_t *ppos, int64_t pos_limit) | ||
3342 | { | ||
3343 | 90 | MpegTSContext *ts = s->priv_data; | |
3344 | AVPacket *pkt; | ||
3345 | int64_t pos; | ||
3346 | 90 | int pos47 = ts->pos47_full % ts->raw_packet_size; | |
3347 | 90 | pos = ((*ppos + ts->raw_packet_size - 1 - pos47) / ts->raw_packet_size) * ts->raw_packet_size + pos47; | |
3348 | 90 | ff_read_frame_flush(s); | |
3349 |
1/2✗ Branch 1 not taken.
✓ Branch 2 taken 90 times.
|
90 | if (avio_seek(s->pb, pos, SEEK_SET) < 0) |
3350 | ✗ | return AV_NOPTS_VALUE; | |
3351 | 90 | pkt = av_packet_alloc(); | |
3352 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 90 times.
|
90 | if (!pkt) |
3353 | ✗ | return AV_NOPTS_VALUE; | |
3354 |
2/2✓ Branch 0 taken 484 times.
✓ Branch 1 taken 12 times.
|
496 | while(pos < pos_limit) { |
3355 | 484 | int ret = av_read_frame(s, pkt); | |
3356 |
2/2✓ Branch 0 taken 18 times.
✓ Branch 1 taken 466 times.
|
484 | if (ret < 0) { |
3357 | 18 | av_packet_free(&pkt); | |
3358 | 18 | return AV_NOPTS_VALUE; | |
3359 | } | ||
3360 |
3/4✓ Branch 0 taken 466 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 163 times.
✓ Branch 3 taken 303 times.
|
466 | if (pkt->dts != AV_NOPTS_VALUE && pkt->pos >= 0) { |
3361 | 163 | ff_reduce_index(s, pkt->stream_index); | |
3362 | 163 | av_add_index_entry(s->streams[pkt->stream_index], pkt->pos, pkt->dts, 0, 0, AVINDEX_KEYFRAME /* FIXME keyframe? */); | |
3363 |
3/4✓ Branch 0 taken 60 times.
✓ Branch 1 taken 103 times.
✓ Branch 2 taken 60 times.
✗ Branch 3 not taken.
|
163 | if (pkt->stream_index == stream_index && pkt->pos >= *ppos) { |
3364 | 60 | int64_t dts = pkt->dts; | |
3365 | 60 | *ppos = pkt->pos; | |
3366 | 60 | av_packet_free(&pkt); | |
3367 | 60 | return dts; | |
3368 | } | ||
3369 | } | ||
3370 | 406 | pos = pkt->pos; | |
3371 | 406 | av_packet_unref(pkt); | |
3372 | } | ||
3373 | |||
3374 | 12 | av_packet_free(&pkt); | |
3375 | 12 | return AV_NOPTS_VALUE; | |
3376 | } | ||
3377 | |||
3378 | /**************************************************************/ | ||
3379 | /* parsing functions - called from other demuxers such as RTP */ | ||
3380 | |||
3381 | ✗ | MpegTSContext *avpriv_mpegts_parse_open(AVFormatContext *s) | |
3382 | { | ||
3383 | MpegTSContext *ts; | ||
3384 | |||
3385 | ✗ | ts = av_mallocz(sizeof(MpegTSContext)); | |
3386 | ✗ | if (!ts) | |
3387 | ✗ | return NULL; | |
3388 | /* no stream case, currently used by RTP */ | ||
3389 | ✗ | ts->raw_packet_size = TS_PACKET_SIZE; | |
3390 | ✗ | ts->max_packet_size = 2048000; | |
3391 | ✗ | ts->stream = s; | |
3392 | ✗ | ts->auto_guess = 1; | |
3393 | |||
3394 | ✗ | mpegts_open_section_filter(ts, SDT_PID, sdt_cb, ts, 1); | |
3395 | ✗ | mpegts_open_section_filter(ts, PAT_PID, pat_cb, ts, 1); | |
3396 | ✗ | mpegts_open_section_filter(ts, EIT_PID, eit_cb, ts, 1); | |
3397 | |||
3398 | ✗ | return ts; | |
3399 | } | ||
3400 | |||
3401 | /* return the consumed length if a packet was output, or -1 if no | ||
3402 | * packet is output */ | ||
3403 | ✗ | int avpriv_mpegts_parse_packet(MpegTSContext *ts, AVPacket *pkt, | |
3404 | const uint8_t *buf, int len) | ||
3405 | { | ||
3406 | int len1; | ||
3407 | |||
3408 | ✗ | len1 = len; | |
3409 | ✗ | ts->pkt = pkt; | |
3410 | for (;;) { | ||
3411 | ✗ | ts->stop_parse = 0; | |
3412 | ✗ | if (len < TS_PACKET_SIZE) | |
3413 | ✗ | return AVERROR_INVALIDDATA; | |
3414 | ✗ | if (buf[0] != 0x47) { | |
3415 | ✗ | buf++; | |
3416 | ✗ | len--; | |
3417 | } else { | ||
3418 | ✗ | handle_packet(ts, buf, len1 - len + TS_PACKET_SIZE); | |
3419 | ✗ | buf += TS_PACKET_SIZE; | |
3420 | ✗ | len -= TS_PACKET_SIZE; | |
3421 | ✗ | if (ts->stop_parse == 1) | |
3422 | ✗ | break; | |
3423 | } | ||
3424 | } | ||
3425 | ✗ | return len1 - len; | |
3426 | } | ||
3427 | |||
3428 | ✗ | void avpriv_mpegts_parse_close(MpegTSContext *ts) | |
3429 | { | ||
3430 | ✗ | mpegts_free(ts); | |
3431 | ✗ | av_free(ts); | |
3432 | ✗ | } | |
3433 | |||
3434 | const FFInputFormat ff_mpegts_demuxer = { | ||
3435 | .p.name = "mpegts", | ||
3436 | .p.long_name = NULL_IF_CONFIG_SMALL("MPEG-TS (MPEG-2 Transport Stream)"), | ||
3437 | .p.flags = AVFMT_SHOW_IDS | AVFMT_TS_DISCONT, | ||
3438 | .p.priv_class = &mpegts_class, | ||
3439 | .priv_data_size = sizeof(MpegTSContext), | ||
3440 | .read_probe = mpegts_probe, | ||
3441 | .read_header = mpegts_read_header, | ||
3442 | .read_packet = mpegts_read_packet, | ||
3443 | .read_close = mpegts_read_close, | ||
3444 | .read_timestamp = mpegts_get_dts, | ||
3445 | }; | ||
3446 | |||
3447 | const FFInputFormat ff_mpegtsraw_demuxer = { | ||
3448 | .p.name = "mpegtsraw", | ||
3449 | .p.long_name = NULL_IF_CONFIG_SMALL("raw MPEG-TS (MPEG-2 Transport Stream)"), | ||
3450 | .p.flags = AVFMT_SHOW_IDS | AVFMT_TS_DISCONT, | ||
3451 | .p.priv_class = &mpegtsraw_class, | ||
3452 | .priv_data_size = sizeof(MpegTSContext), | ||
3453 | .read_header = mpegts_read_header, | ||
3454 | .read_packet = mpegts_raw_read_packet, | ||
3455 | .read_close = mpegts_read_close, | ||
3456 | .read_timestamp = mpegts_get_dts, | ||
3457 | }; | ||
3458 |