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/common.h" | ||
26 | #include "libavutil/crc.h" | ||
27 | #include "libavutil/internal.h" | ||
28 | #include "libavutil/intreadwrite.h" | ||
29 | #include "libavutil/log.h" | ||
30 | #include "libavutil/dict.h" | ||
31 | #include "libavutil/mathematics.h" | ||
32 | #include "libavutil/opt.h" | ||
33 | #include "libavutil/avassert.h" | ||
34 | #include "libavutil/dovi_meta.h" | ||
35 | #include "libavcodec/avcodec.h" | ||
36 | #include "libavcodec/bytestream.h" | ||
37 | #include "libavcodec/defs.h" | ||
38 | #include "libavcodec/get_bits.h" | ||
39 | #include "libavcodec/opus.h" | ||
40 | #include "avformat.h" | ||
41 | #include "mpegts.h" | ||
42 | #include "internal.h" | ||
43 | #include "avio_internal.h" | ||
44 | #include "demux.h" | ||
45 | #include "mpeg.h" | ||
46 | #include "isom.h" | ||
47 | #if CONFIG_ICONV | ||
48 | #include <iconv.h> | ||
49 | #endif | ||
50 | |||
51 | /* maximum size in which we look for synchronization if | ||
52 | * synchronization is lost */ | ||
53 | #define MAX_RESYNC_SIZE 65536 | ||
54 | |||
55 | #define MAX_MP4_DESCR_COUNT 16 | ||
56 | |||
57 | #define MOD_UNLIKELY(modulus, dividend, divisor, prev_dividend) \ | ||
58 | do { \ | ||
59 | if ((prev_dividend) == 0 || (dividend) - (prev_dividend) != (divisor)) \ | ||
60 | (modulus) = (dividend) % (divisor); \ | ||
61 | (prev_dividend) = (dividend); \ | ||
62 | } while (0) | ||
63 | |||
64 | #define PROBE_PACKET_MAX_BUF 8192 | ||
65 | #define PROBE_PACKET_MARGIN 5 | ||
66 | |||
67 | enum MpegTSFilterType { | ||
68 | MPEGTS_PES, | ||
69 | MPEGTS_SECTION, | ||
70 | MPEGTS_PCR, | ||
71 | }; | ||
72 | |||
73 | typedef struct MpegTSFilter MpegTSFilter; | ||
74 | |||
75 | typedef int PESCallback (MpegTSFilter *f, const uint8_t *buf, int len, | ||
76 | int is_start, int64_t pos); | ||
77 | |||
78 | typedef struct MpegTSPESFilter { | ||
79 | PESCallback *pes_cb; | ||
80 | void *opaque; | ||
81 | } MpegTSPESFilter; | ||
82 | |||
83 | typedef void SectionCallback (MpegTSFilter *f, const uint8_t *buf, int len); | ||
84 | |||
85 | typedef void SetServiceCallback (void *opaque, int ret); | ||
86 | |||
87 | typedef struct MpegTSSectionFilter { | ||
88 | int section_index; | ||
89 | int section_h_size; | ||
90 | int last_ver; | ||
91 | unsigned crc; | ||
92 | unsigned last_crc; | ||
93 | uint8_t *section_buf; | ||
94 | unsigned int check_crc : 1; | ||
95 | unsigned int end_of_section_reached : 1; | ||
96 | SectionCallback *section_cb; | ||
97 | void *opaque; | ||
98 | } MpegTSSectionFilter; | ||
99 | |||
100 | struct MpegTSFilter { | ||
101 | int pid; | ||
102 | int es_id; | ||
103 | int last_cc; /* last cc code (-1 if first packet) */ | ||
104 | int64_t last_pcr; | ||
105 | int discard; | ||
106 | enum MpegTSFilterType type; | ||
107 | union { | ||
108 | MpegTSPESFilter pes_filter; | ||
109 | MpegTSSectionFilter section_filter; | ||
110 | } u; | ||
111 | }; | ||
112 | |||
113 | struct Stream { | ||
114 | int idx; | ||
115 | int stream_identifier; | ||
116 | }; | ||
117 | |||
118 | #define MAX_STREAMS_PER_PROGRAM 128 | ||
119 | #define MAX_PIDS_PER_PROGRAM (MAX_STREAMS_PER_PROGRAM + 2) | ||
120 | struct Program { | ||
121 | unsigned int id; // program id/service id | ||
122 | unsigned int nb_pids; | ||
123 | unsigned int pids[MAX_PIDS_PER_PROGRAM]; | ||
124 | unsigned int nb_streams; | ||
125 | struct Stream streams[MAX_STREAMS_PER_PROGRAM]; | ||
126 | |||
127 | /** have we found pmt for this program */ | ||
128 | int pmt_found; | ||
129 | }; | ||
130 | |||
131 | struct MpegTSContext { | ||
132 | const AVClass *class; | ||
133 | /* user data */ | ||
134 | AVFormatContext *stream; | ||
135 | /** raw packet size, including FEC if present */ | ||
136 | int raw_packet_size; | ||
137 | |||
138 | int64_t pos47_full; | ||
139 | |||
140 | /** if true, all pids are analyzed to find streams */ | ||
141 | int auto_guess; | ||
142 | |||
143 | /** compute exact PCR for each transport stream packet */ | ||
144 | int mpeg2ts_compute_pcr; | ||
145 | |||
146 | /** fix dvb teletext pts */ | ||
147 | int fix_teletext_pts; | ||
148 | |||
149 | int64_t cur_pcr; /**< used to estimate the exact PCR */ | ||
150 | int64_t pcr_incr; /**< used to estimate the exact PCR */ | ||
151 | |||
152 | /* data needed to handle file based ts */ | ||
153 | /** stop parsing loop */ | ||
154 | int stop_parse; | ||
155 | /** packet containing Audio/Video data */ | ||
156 | AVPacket *pkt; | ||
157 | /** to detect seek */ | ||
158 | int64_t last_pos; | ||
159 | |||
160 | int skip_changes; | ||
161 | int skip_clear; | ||
162 | int skip_unknown_pmt; | ||
163 | |||
164 | int scan_all_pmts; | ||
165 | |||
166 | int resync_size; | ||
167 | int merge_pmt_versions; | ||
168 | int max_packet_size; | ||
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", offsetof(MpegTSContext, resync_size), AV_OPT_TYPE_INT, { .i64 = MAX_RESYNC_SIZE}, 0, INT_MAX, AV_OPT_FLAG_DECODING_PARAM } | ||
188 | |||
189 | static const AVOption options[] = { | ||
190 | MPEGTS_OPTIONS, | ||
191 | {"fix_teletext_pts", "try to fix pts values of dvb teletext streams", offsetof(MpegTSContext, fix_teletext_pts), AV_OPT_TYPE_BOOL, | ||
192 | {.i64 = 1}, 0, 1, AV_OPT_FLAG_DECODING_PARAM }, | ||
193 | {"ts_packetsize", "output option carrying the raw packet size", offsetof(MpegTSContext, raw_packet_size), AV_OPT_TYPE_INT, | ||
194 | {.i64 = 0}, 0, 0, AV_OPT_FLAG_DECODING_PARAM | AV_OPT_FLAG_EXPORT | AV_OPT_FLAG_READONLY }, | ||
195 | {"scan_all_pmts", "scan and combine all PMTs", offsetof(MpegTSContext, scan_all_pmts), AV_OPT_TYPE_BOOL, | ||
196 | {.i64 = -1}, -1, 1, AV_OPT_FLAG_DECODING_PARAM }, | ||
197 | {"skip_unknown_pmt", "skip PMTs for programs not advertised in the PAT", offsetof(MpegTSContext, skip_unknown_pmt), AV_OPT_TYPE_BOOL, | ||
198 | {.i64 = 0}, 0, 1, AV_OPT_FLAG_DECODING_PARAM }, | ||
199 | {"merge_pmt_versions", "re-use streams when PMT's version/pids change", offsetof(MpegTSContext, merge_pmt_versions), AV_OPT_TYPE_BOOL, | ||
200 | {.i64 = 0}, 0, 1, AV_OPT_FLAG_DECODING_PARAM }, | ||
201 | {"skip_changes", "skip changing / adding streams / programs", offsetof(MpegTSContext, skip_changes), AV_OPT_TYPE_BOOL, | ||
202 | {.i64 = 0}, 0, 1, 0 }, | ||
203 | {"skip_clear", "skip clearing programs", offsetof(MpegTSContext, skip_clear), AV_OPT_TYPE_BOOL, | ||
204 | {.i64 = 0}, 0, 1, 0 }, | ||
205 | {"max_packet_size", "maximum size of emitted packet", offsetof(MpegTSContext, max_packet_size), AV_OPT_TYPE_INT, | ||
206 | {.i64 = 204800}, 1, INT_MAX/2, AV_OPT_FLAG_DECODING_PARAM }, | ||
207 | { NULL }, | ||
208 | }; | ||
209 | |||
210 | static const AVClass mpegts_class = { | ||
211 | .class_name = "mpegts demuxer", | ||
212 | .item_name = av_default_item_name, | ||
213 | .option = options, | ||
214 | .version = LIBAVUTIL_VERSION_INT, | ||
215 | }; | ||
216 | |||
217 | static const AVOption raw_options[] = { | ||
218 | MPEGTS_OPTIONS, | ||
219 | { "compute_pcr", "compute exact PCR for each transport stream packet", | ||
220 | offsetof(MpegTSContext, mpeg2ts_compute_pcr), AV_OPT_TYPE_BOOL, | ||
221 | { .i64 = 0 }, 0, 1, AV_OPT_FLAG_DECODING_PARAM }, | ||
222 | { "ts_packetsize", "output option carrying the raw packet size", | ||
223 | offsetof(MpegTSContext, raw_packet_size), AV_OPT_TYPE_INT, | ||
224 | { .i64 = 0 }, 0, 0, | ||
225 | AV_OPT_FLAG_DECODING_PARAM | AV_OPT_FLAG_EXPORT | AV_OPT_FLAG_READONLY }, | ||
226 | { NULL }, | ||
227 | }; | ||
228 | |||
229 | static const AVClass mpegtsraw_class = { | ||
230 | .class_name = "mpegtsraw demuxer", | ||
231 | .item_name = av_default_item_name, | ||
232 | .option = raw_options, | ||
233 | .version = LIBAVUTIL_VERSION_INT, | ||
234 | }; | ||
235 | |||
236 | /* TS stream handling */ | ||
237 | |||
238 | enum MpegTSState { | ||
239 | MPEGTS_HEADER = 0, | ||
240 | MPEGTS_PESHEADER, | ||
241 | MPEGTS_PESHEADER_FILL, | ||
242 | MPEGTS_PAYLOAD, | ||
243 | MPEGTS_SKIP, | ||
244 | }; | ||
245 | |||
246 | /* enough for PES header + length */ | ||
247 | #define PES_START_SIZE 6 | ||
248 | #define PES_HEADER_SIZE 9 | ||
249 | #define MAX_PES_HEADER_SIZE (9 + 255) | ||
250 | |||
251 | typedef struct PESContext { | ||
252 | int pid; | ||
253 | int pcr_pid; /**< if -1 then all packets containing PCR are considered */ | ||
254 | int stream_type; | ||
255 | MpegTSContext *ts; | ||
256 | AVFormatContext *stream; | ||
257 | AVStream *st; | ||
258 | AVStream *sub_st; /**< stream for the embedded AC3 stream in HDMV TrueHD */ | ||
259 | enum MpegTSState state; | ||
260 | /* used to get the format */ | ||
261 | int data_index; | ||
262 | int flags; /**< copied to the AVPacket flags */ | ||
263 | int PES_packet_length; | ||
264 | int pes_header_size; | ||
265 | int extended_stream_id; | ||
266 | uint8_t stream_id; | ||
267 | int64_t pts, dts; | ||
268 | int64_t ts_packet_pos; /**< position of first TS packet of this PES packet */ | ||
269 | uint8_t header[MAX_PES_HEADER_SIZE]; | ||
270 | AVBufferRef *buffer; | ||
271 | SLConfigDescr sl; | ||
272 | int merged_st; | ||
273 | } PESContext; | ||
274 | |||
275 | extern const AVInputFormat ff_mpegts_demuxer; | ||
276 | |||
277 | 473 | static struct Program * get_program(MpegTSContext *ts, unsigned int programid) | |
278 | { | ||
279 | int i; | ||
280 |
2/2✓ Branch 0 taken 419 times.
✓ Branch 1 taken 54 times.
|
473 | for (i = 0; i < ts->nb_prg; i++) { |
281 |
1/2✓ Branch 0 taken 419 times.
✗ Branch 1 not taken.
|
419 | if (ts->prg[i].id == programid) { |
282 | 419 | return &ts->prg[i]; | |
283 | } | ||
284 | } | ||
285 | 54 | return NULL; | |
286 | } | ||
287 | |||
288 | 169 | static void clear_avprogram(MpegTSContext *ts, unsigned int programid) | |
289 | { | ||
290 | 169 | AVProgram *prg = NULL; | |
291 | int i; | ||
292 | |||
293 |
1/2✓ Branch 0 taken 169 times.
✗ Branch 1 not taken.
|
169 | for (i = 0; i < ts->stream->nb_programs; i++) |
294 |
1/2✓ Branch 0 taken 169 times.
✗ Branch 1 not taken.
|
169 | if (ts->stream->programs[i]->id == programid) { |
295 | 169 | prg = ts->stream->programs[i]; | |
296 | 169 | break; | |
297 | } | ||
298 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 169 times.
|
169 | if (!prg) |
299 | ✗ | return; | |
300 | 169 | prg->nb_stream_indexes = 0; | |
301 | } | ||
302 | |||
303 | 317 | static void clear_program(struct Program *p) | |
304 | { | ||
305 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 317 times.
|
317 | if (!p) |
306 | ✗ | return; | |
307 | 317 | p->nb_pids = 0; | |
308 | 317 | p->nb_streams = 0; | |
309 | 317 | p->pmt_found = 0; | |
310 | } | ||
311 | |||
312 | 54 | static void clear_programs(MpegTSContext *ts) | |
313 | { | ||
314 | 54 | av_freep(&ts->prg); | |
315 | 54 | ts->nb_prg = 0; | |
316 | 54 | } | |
317 | |||
318 | 210 | static struct Program * add_program(MpegTSContext *ts, unsigned int programid) | |
319 | { | ||
320 | 210 | struct Program *p = get_program(ts, programid); | |
321 |
2/2✓ Branch 0 taken 156 times.
✓ Branch 1 taken 54 times.
|
210 | if (p) |
322 | 156 | return p; | |
323 |
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) { |
324 | ✗ | ts->nb_prg = 0; | |
325 | ✗ | return NULL; | |
326 | } | ||
327 | 54 | p = &ts->prg[ts->nb_prg]; | |
328 | 54 | p->id = programid; | |
329 | 54 | clear_program(p); | |
330 | 54 | ts->nb_prg++; | |
331 | 54 | return p; | |
332 | } | ||
333 | |||
334 | 1255 | static void add_pid_to_program(struct Program *p, unsigned int pid) | |
335 | { | ||
336 | int i; | ||
337 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 1255 times.
|
1255 | if (!p) |
338 | ✗ | return; | |
339 | |||
340 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 1255 times.
|
1255 | if (p->nb_pids >= MAX_PIDS_PER_PROGRAM) |
341 | ✗ | return; | |
342 | |||
343 |
2/2✓ Branch 0 taken 1621 times.
✓ Branch 1 taken 830 times.
|
2451 | for (i = 0; i < p->nb_pids; i++) |
344 |
2/2✓ Branch 0 taken 425 times.
✓ Branch 1 taken 1196 times.
|
1621 | if (p->pids[i] == pid) |
345 | 425 | return; | |
346 | |||
347 | 830 | p->pids[p->nb_pids++] = pid; | |
348 | } | ||
349 | |||
350 | 263 | static void update_av_program_info(AVFormatContext *s, unsigned int programid, | |
351 | unsigned int pid, int version) | ||
352 | { | ||
353 | int i; | ||
354 |
1/2✓ Branch 0 taken 263 times.
✗ Branch 1 not taken.
|
263 | for (i = 0; i < s->nb_programs; i++) { |
355 | 263 | AVProgram *program = s->programs[i]; | |
356 |
1/2✓ Branch 0 taken 263 times.
✗ Branch 1 not taken.
|
263 | if (program->id == programid) { |
357 | 263 | int old_pcr_pid = program->pcr_pid, | |
358 | 263 | old_version = program->pmt_version; | |
359 | 263 | program->pcr_pid = pid; | |
360 | 263 | program->pmt_version = version; | |
361 | |||
362 |
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) { |
363 | 13 | av_log(s, AV_LOG_VERBOSE, | |
364 | "detected PMT change (program=%d, version=%d/%d, pcr_pid=0x%x/0x%x)\n", | ||
365 | programid, old_version, version, old_pcr_pid, pid); | ||
366 | } | ||
367 | 263 | break; | |
368 | } | ||
369 | } | ||
370 | 263 | } | |
371 | |||
372 | /** | ||
373 | * @brief discard_pid() decides if the pid is to be discarded according | ||
374 | * to caller's programs selection | ||
375 | * @param ts : - TS context | ||
376 | * @param pid : - pid | ||
377 | * @return 1 if the pid is only comprised in programs that have .discard=AVDISCARD_ALL | ||
378 | * 0 otherwise | ||
379 | */ | ||
380 | 36047 | static int discard_pid(MpegTSContext *ts, unsigned int pid) | |
381 | { | ||
382 | int i, j, k; | ||
383 | 36047 | int used = 0, discarded = 0; | |
384 | struct Program *p; | ||
385 | |||
386 |
2/2✓ Branch 0 taken 3007 times.
✓ Branch 1 taken 33040 times.
|
36047 | if (pid == PAT_PID) |
387 | 3007 | return 0; | |
388 | |||
389 | /* If none of the programs have .discard=AVDISCARD_ALL then there's | ||
390 | * no way we have to discard this packet */ | ||
391 |
2/2✓ Branch 0 taken 33013 times.
✓ Branch 1 taken 33040 times.
|
66053 | for (k = 0; k < ts->stream->nb_programs; k++) |
392 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 33013 times.
|
33013 | if (ts->stream->programs[k]->discard == AVDISCARD_ALL) |
393 | ✗ | break; | |
394 |
1/2✓ Branch 0 taken 33040 times.
✗ Branch 1 not taken.
|
33040 | if (k == ts->stream->nb_programs) |
395 | 33040 | return 0; | |
396 | |||
397 | ✗ | for (i = 0; i < ts->nb_prg; i++) { | |
398 | ✗ | p = &ts->prg[i]; | |
399 | ✗ | for (j = 0; j < p->nb_pids; j++) { | |
400 | ✗ | if (p->pids[j] != pid) | |
401 | ✗ | continue; | |
402 | // is program with id p->id set to be discarded? | ||
403 | ✗ | for (k = 0; k < ts->stream->nb_programs; k++) { | |
404 | ✗ | if (ts->stream->programs[k]->id == p->id) { | |
405 | ✗ | if (ts->stream->programs[k]->discard == AVDISCARD_ALL) | |
406 | ✗ | discarded++; | |
407 | else | ||
408 | ✗ | used++; | |
409 | } | ||
410 | } | ||
411 | } | ||
412 | } | ||
413 | |||
414 | ✗ | return !used && discarded; | |
415 | } | ||
416 | |||
417 | /** | ||
418 | * Assemble PES packets out of TS packets, and then call the "section_cb" | ||
419 | * function when they are complete. | ||
420 | */ | ||
421 | 6472 | static void write_section_data(MpegTSContext *ts, MpegTSFilter *tss1, | |
422 | const uint8_t *buf, int buf_size, int is_start) | ||
423 | { | ||
424 | 6472 | MpegTSSectionFilter *tss = &tss1->u.section_filter; | |
425 | 6472 | uint8_t *cur_section_buf = NULL; | |
426 | int len, offset; | ||
427 | |||
428 |
2/2✓ Branch 0 taken 6437 times.
✓ Branch 1 taken 35 times.
|
6472 | if (is_start) { |
429 | 6437 | memcpy(tss->section_buf, buf, buf_size); | |
430 | 6437 | tss->section_index = buf_size; | |
431 | 6437 | tss->section_h_size = -1; | |
432 | 6437 | tss->end_of_section_reached = 0; | |
433 | } else { | ||
434 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 35 times.
|
35 | if (tss->end_of_section_reached) |
435 | ✗ | return; | |
436 | 35 | len = MAX_SECTION_SIZE - tss->section_index; | |
437 |
1/2✓ Branch 0 taken 35 times.
✗ Branch 1 not taken.
|
35 | if (buf_size < len) |
438 | 35 | len = buf_size; | |
439 | 35 | memcpy(tss->section_buf + tss->section_index, buf, len); | |
440 | 35 | tss->section_index += len; | |
441 | } | ||
442 | |||
443 | 6472 | offset = 0; | |
444 | 6472 | cur_section_buf = tss->section_buf; | |
445 |
3/4✓ Branch 0 taken 12909 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 6680 times.
✓ Branch 3 taken 6229 times.
|
12909 | while (cur_section_buf - tss->section_buf < MAX_SECTION_SIZE && cur_section_buf[0] != 0xff) { |
446 | /* compute section length if possible */ | ||
447 |
3/4✓ Branch 0 taken 6680 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 6472 times.
✓ Branch 3 taken 208 times.
|
6680 | if (tss->section_h_size == -1 && tss->section_index - offset >= 3) { |
448 | 6472 | len = (AV_RB16(cur_section_buf + 1) & 0xfff) + 3; | |
449 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 6472 times.
|
6472 | if (len > MAX_SECTION_SIZE) |
450 | ✗ | return; | |
451 | 6472 | tss->section_h_size = len; | |
452 | } | ||
453 | |||
454 |
2/2✓ Branch 0 taken 6472 times.
✓ Branch 1 taken 208 times.
|
6680 | if (tss->section_h_size != -1 && |
455 |
2/2✓ Branch 0 taken 6437 times.
✓ Branch 1 taken 35 times.
|
6472 | tss->section_index >= offset + tss->section_h_size) { |
456 | 6437 | int crc_valid = 1; | |
457 | 6437 | tss->end_of_section_reached = 1; | |
458 | |||
459 |
1/2✓ Branch 0 taken 6437 times.
✗ Branch 1 not taken.
|
6437 | if (tss->check_crc) { |
460 | 6437 | crc_valid = !av_crc(av_crc_get_table(AV_CRC_32_IEEE), -1, cur_section_buf, tss->section_h_size); | |
461 |
1/2✓ Branch 0 taken 6437 times.
✗ Branch 1 not taken.
|
6437 | if (tss->section_h_size >= 4) |
462 | 6437 | tss->crc = AV_RB32(cur_section_buf + tss->section_h_size - 4); | |
463 | |||
464 |
1/2✓ Branch 0 taken 6437 times.
✗ Branch 1 not taken.
|
6437 | if (crc_valid) { |
465 | 6437 | ts->crc_validity[ tss1->pid ] = 100; | |
466 | ✗ | }else if (ts->crc_validity[ tss1->pid ] > -10) { | |
467 | ✗ | ts->crc_validity[ tss1->pid ]--; | |
468 | }else | ||
469 | ✗ | crc_valid = 2; | |
470 | } | ||
471 |
1/2✓ Branch 0 taken 6437 times.
✗ Branch 1 not taken.
|
6437 | if (crc_valid) { |
472 | 6437 | tss->section_cb(tss1, cur_section_buf, tss->section_h_size); | |
473 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 6437 times.
|
6437 | if (crc_valid != 1) |
474 | ✗ | tss->last_ver = -1; | |
475 | } | ||
476 | |||
477 | 6437 | cur_section_buf += tss->section_h_size; | |
478 | 6437 | offset += tss->section_h_size; | |
479 | 6437 | tss->section_h_size = -1; | |
480 | } else { | ||
481 | 243 | tss->section_h_size = -1; | |
482 | 243 | tss->end_of_section_reached = 0; | |
483 | 243 | break; | |
484 | } | ||
485 | } | ||
486 | } | ||
487 | |||
488 | 339 | static MpegTSFilter *mpegts_open_filter(MpegTSContext *ts, unsigned int pid, | |
489 | enum MpegTSFilterType type) | ||
490 | { | ||
491 | MpegTSFilter *filter; | ||
492 | |||
493 | 339 | av_log(ts->stream, AV_LOG_TRACE, "Filter: pid=0x%x type=%d\n", pid, type); | |
494 | |||
495 |
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]) |
496 | ✗ | return NULL; | |
497 | 339 | filter = av_mallocz(sizeof(MpegTSFilter)); | |
498 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 339 times.
|
339 | if (!filter) |
499 | ✗ | return NULL; | |
500 | 339 | ts->pids[pid] = filter; | |
501 | |||
502 | 339 | filter->type = type; | |
503 | 339 | filter->pid = pid; | |
504 | 339 | filter->es_id = -1; | |
505 | 339 | filter->last_cc = -1; | |
506 | 339 | filter->last_pcr= -1; | |
507 | |||
508 | 339 | return filter; | |
509 | } | ||
510 | |||
511 | 221 | static MpegTSFilter *mpegts_open_section_filter(MpegTSContext *ts, | |
512 | unsigned int pid, | ||
513 | SectionCallback *section_cb, | ||
514 | void *opaque, | ||
515 | int check_crc) | ||
516 | { | ||
517 | MpegTSFilter *filter; | ||
518 | MpegTSSectionFilter *sec; | ||
519 | 221 | uint8_t *section_buf = av_mallocz(MAX_SECTION_SIZE); | |
520 | |||
521 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 221 times.
|
221 | if (!section_buf) |
522 | ✗ | return NULL; | |
523 | |||
524 |
1/2✗ Branch 1 not taken.
✓ Branch 2 taken 221 times.
|
221 | if (!(filter = mpegts_open_filter(ts, pid, MPEGTS_SECTION))) { |
525 | ✗ | av_free(section_buf); | |
526 | ✗ | return NULL; | |
527 | } | ||
528 | 221 | sec = &filter->u.section_filter; | |
529 | 221 | sec->section_cb = section_cb; | |
530 | 221 | sec->opaque = opaque; | |
531 | 221 | sec->section_buf = section_buf; | |
532 | 221 | sec->check_crc = check_crc; | |
533 | 221 | sec->last_ver = -1; | |
534 | |||
535 | 221 | return filter; | |
536 | } | ||
537 | |||
538 | 118 | static MpegTSFilter *mpegts_open_pes_filter(MpegTSContext *ts, unsigned int pid, | |
539 | PESCallback *pes_cb, | ||
540 | void *opaque) | ||
541 | { | ||
542 | MpegTSFilter *filter; | ||
543 | MpegTSPESFilter *pes; | ||
544 | |||
545 |
1/2✗ Branch 1 not taken.
✓ Branch 2 taken 118 times.
|
118 | if (!(filter = mpegts_open_filter(ts, pid, MPEGTS_PES))) |
546 | ✗ | return NULL; | |
547 | |||
548 | 118 | pes = &filter->u.pes_filter; | |
549 | 118 | pes->pes_cb = pes_cb; | |
550 | 118 | pes->opaque = opaque; | |
551 | 118 | return filter; | |
552 | } | ||
553 | |||
554 | ✗ | static MpegTSFilter *mpegts_open_pcr_filter(MpegTSContext *ts, unsigned int pid) | |
555 | { | ||
556 | ✗ | return mpegts_open_filter(ts, pid, MPEGTS_PCR); | |
557 | } | ||
558 | |||
559 | 339 | static void mpegts_close_filter(MpegTSContext *ts, MpegTSFilter *filter) | |
560 | { | ||
561 | int pid; | ||
562 | |||
563 | 339 | pid = filter->pid; | |
564 |
2/2✓ Branch 0 taken 221 times.
✓ Branch 1 taken 118 times.
|
339 | if (filter->type == MPEGTS_SECTION) |
565 | 221 | av_freep(&filter->u.section_filter.section_buf); | |
566 |
1/2✓ Branch 0 taken 118 times.
✗ Branch 1 not taken.
|
118 | else if (filter->type == MPEGTS_PES) { |
567 | 118 | PESContext *pes = filter->u.pes_filter.opaque; | |
568 | 118 | av_buffer_unref(&pes->buffer); | |
569 | /* referenced private data will be freed later in | ||
570 | * avformat_close_input (pes->st->priv_data == pes) */ | ||
571 |
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) { |
572 | 21 | av_freep(&filter->u.pes_filter.opaque); | |
573 | } | ||
574 | } | ||
575 | |||
576 | 339 | av_free(filter); | |
577 | 339 | ts->pids[pid] = NULL; | |
578 | 339 | } | |
579 | |||
580 | 36417 | static int analyze(const uint8_t *buf, int size, int packet_size, | |
581 | int probe) | ||
582 | { | ||
583 | int stat[TS_MAX_PACKET_SIZE]; | ||
584 | 36417 | int stat_all = 0; | |
585 | int i; | ||
586 | 36417 | int best_score = 0; | |
587 | |||
588 | 36417 | memset(stat, 0, packet_size * sizeof(*stat)); | |
589 | |||
590 |
2/2✓ Branch 0 taken 410174605 times.
✓ Branch 1 taken 36417 times.
|
410211022 | for (i = 0; i < size - 3; i++) { |
591 |
2/2✓ Branch 0 taken 758342 times.
✓ Branch 1 taken 409416263 times.
|
410174605 | if (buf[i] == 0x47) { |
592 | 758342 | int pid = AV_RB16(buf+1) & 0x1FFF; | |
593 | 758342 | int asc = buf[i + 3] & 0x30; | |
594 |
6/6✓ Branch 0 taken 736769 times.
✓ Branch 1 taken 21573 times.
✓ Branch 2 taken 736165 times.
✓ Branch 3 taken 604 times.
✓ Branch 4 taken 589139 times.
✓ Branch 5 taken 147026 times.
|
758342 | if (!probe || pid == 0x1FFF || asc) { |
595 | 611316 | int x = i % packet_size; | |
596 | 611316 | stat[x]++; | |
597 | 611316 | stat_all++; | |
598 |
2/2✓ Branch 0 taken 57654 times.
✓ Branch 1 taken 553662 times.
|
611316 | if (stat[x] > best_score) { |
599 | 57654 | best_score = stat[x]; | |
600 | } | ||
601 | } | ||
602 | } | ||
603 | } | ||
604 | |||
605 | 36417 | return best_score - FFMAX(stat_all - 10*best_score, 0)/10; | |
606 | } | ||
607 | |||
608 | /* autodetect fec presence */ | ||
609 | 112 | static int get_packet_size(AVFormatContext* s) | |
610 | { | ||
611 | int score, fec_score, dvhs_score; | ||
612 | int margin; | ||
613 | int ret; | ||
614 | |||
615 | /*init buffer to store stream for probing */ | ||
616 | 112 | uint8_t buf[PROBE_PACKET_MAX_BUF] = {0}; | |
617 | 112 | int buf_size = 0; | |
618 | 112 | int max_iterations = 16; | |
619 | |||
620 |
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--) { |
621 | 112 | ret = avio_read_partial(s->pb, buf + buf_size, PROBE_PACKET_MAX_BUF - buf_size); | |
622 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 112 times.
|
112 | if (ret < 0) |
623 | ✗ | return AVERROR_INVALIDDATA; | |
624 | 112 | buf_size += ret; | |
625 | |||
626 | 112 | score = analyze(buf, buf_size, TS_PACKET_SIZE, 0); | |
627 | 112 | dvhs_score = analyze(buf, buf_size, TS_DVHS_PACKET_SIZE, 0); | |
628 | 112 | fec_score = analyze(buf, buf_size, TS_FEC_PACKET_SIZE, 0); | |
629 | 112 | av_log(s, AV_LOG_TRACE, "Probe: %d, score: %d, dvhs_score: %d, fec_score: %d \n", | |
630 | buf_size, score, dvhs_score, fec_score); | ||
631 | |||
632 | 112 | margin = mid_pred(score, fec_score, dvhs_score); | |
633 | |||
634 |
2/2✓ Branch 0 taken 1 times.
✓ Branch 1 taken 111 times.
|
112 | if (buf_size < PROBE_PACKET_MAX_BUF) |
635 | 1 | margin += PROBE_PACKET_MARGIN; /*if buffer not filled */ | |
636 | |||
637 |
1/2✓ Branch 0 taken 112 times.
✗ Branch 1 not taken.
|
112 | if (score > margin) |
638 | 112 | return TS_PACKET_SIZE; | |
639 | ✗ | else if (dvhs_score > margin) | |
640 | ✗ | return TS_DVHS_PACKET_SIZE; | |
641 | ✗ | else if (fec_score > margin) | |
642 | ✗ | return TS_FEC_PACKET_SIZE; | |
643 | } | ||
644 | ✗ | return AVERROR_INVALIDDATA; | |
645 | } | ||
646 | |||
647 | typedef struct SectionHeader { | ||
648 | uint8_t tid; | ||
649 | uint16_t id; | ||
650 | uint8_t version; | ||
651 | uint8_t current_next; | ||
652 | uint8_t sec_num; | ||
653 | uint8_t last_sec_num; | ||
654 | } SectionHeader; | ||
655 | |||
656 | 5790 | static int skip_identical(const SectionHeader *h, MpegTSSectionFilter *tssf) | |
657 | { | ||
658 |
3/4✓ Branch 0 taken 5217 times.
✓ Branch 1 taken 573 times.
✓ Branch 2 taken 5217 times.
✗ Branch 3 not taken.
|
5790 | if (h->version == tssf->last_ver && tssf->last_crc == tssf->crc) |
659 | 5217 | return 1; | |
660 | |||
661 | 573 | tssf->last_ver = h->version; | |
662 | 573 | tssf->last_crc = tssf->crc; | |
663 | |||
664 | 573 | return 0; | |
665 | } | ||
666 | |||
667 | 30894 | static inline int get8(const uint8_t **pp, const uint8_t *p_end) | |
668 | { | ||
669 | const uint8_t *p; | ||
670 | int c; | ||
671 | |||
672 | 30894 | p = *pp; | |
673 |
2/2✓ Branch 0 taken 1373 times.
✓ Branch 1 taken 29521 times.
|
30894 | if (p >= p_end) |
674 | 1373 | return AVERROR_INVALIDDATA; | |
675 | 29521 | c = *p++; | |
676 | 29521 | *pp = p; | |
677 | 29521 | return c; | |
678 | } | ||
679 | |||
680 | 9552 | static inline int get16(const uint8_t **pp, const uint8_t *p_end) | |
681 | { | ||
682 | const uint8_t *p; | ||
683 | int c; | ||
684 | |||
685 | 9552 | p = *pp; | |
686 |
2/2✓ Branch 0 taken 310 times.
✓ Branch 1 taken 9242 times.
|
9552 | if (1 >= p_end - p) |
687 | 310 | return AVERROR_INVALIDDATA; | |
688 | 9242 | c = AV_RB16(p); | |
689 | 9242 | p += 2; | |
690 | 9242 | *pp = p; | |
691 | 9242 | return c; | |
692 | } | ||
693 | |||
694 | /* read and allocate a DVB string preceded by its length */ | ||
695 | 200 | static char *getstr8(const uint8_t **pp, const uint8_t *p_end) | |
696 | { | ||
697 | int len; | ||
698 | const uint8_t *p; | ||
699 | char *str; | ||
700 | |||
701 | 200 | p = *pp; | |
702 | 200 | len = get8(&p, p_end); | |
703 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 200 times.
|
200 | if (len < 0) |
704 | ✗ | return NULL; | |
705 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 200 times.
|
200 | if (len > p_end - p) |
706 | ✗ | return NULL; | |
707 | #if CONFIG_ICONV | ||
708 |
1/2✓ Branch 0 taken 200 times.
✗ Branch 1 not taken.
|
200 | if (len) { |
709 | 200 | const char *encodings[] = { | |
710 | "ISO6937", "ISO-8859-5", "ISO-8859-6", "ISO-8859-7", | ||
711 | "ISO-8859-8", "ISO-8859-9", "ISO-8859-10", "ISO-8859-11", | ||
712 | "", "ISO-8859-13", "ISO-8859-14", "ISO-8859-15", "", "", "", "", | ||
713 | "", "UCS-2BE", "KSC_5601", "GB2312", "UCS-2BE", "UTF-8", "", "", | ||
714 | "", "", "", "", "", "", "", "" | ||
715 | }; | ||
716 | iconv_t cd; | ||
717 | char *in, *out; | ||
718 | 200 | size_t inlen = len, outlen = inlen * 6 + 1; | |
719 |
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) { |
720 | char iso8859[12]; | ||
721 | ✗ | snprintf(iso8859, sizeof(iso8859), "ISO-8859-%d", p[2]); | |
722 | ✗ | inlen -= 3; | |
723 | ✗ | in = (char *)p + 3; | |
724 | ✗ | cd = iconv_open("UTF-8", iso8859); | |
725 |
2/2✓ Branch 0 taken 8 times.
✓ Branch 1 taken 192 times.
|
200 | } else if (p[0] < 0x20) { |
726 | 8 | inlen -= 1; | |
727 | 8 | in = (char *)p + 1; | |
728 | 8 | cd = iconv_open("UTF-8", encodings[*p]); | |
729 | } else { | ||
730 | 192 | in = (char *)p; | |
731 | 192 | cd = iconv_open("UTF-8", encodings[0]); | |
732 | } | ||
733 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 200 times.
|
200 | if (cd == (iconv_t)-1) |
734 | ✗ | goto no_iconv; | |
735 | 200 | str = out = av_malloc(outlen); | |
736 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 200 times.
|
200 | if (!str) { |
737 | ✗ | iconv_close(cd); | |
738 | 200 | return NULL; | |
739 | } | ||
740 |
1/2✗ Branch 1 not taken.
✓ Branch 2 taken 200 times.
|
200 | if (iconv(cd, &in, &inlen, &out, &outlen) == -1) { |
741 | ✗ | iconv_close(cd); | |
742 | ✗ | av_freep(&str); | |
743 | ✗ | goto no_iconv; | |
744 | } | ||
745 | 200 | iconv_close(cd); | |
746 | 200 | *out = 0; | |
747 | 200 | *pp = p + len; | |
748 | 200 | return str; | |
749 | } | ||
750 | ✗ | no_iconv: | |
751 | #endif | ||
752 | ✗ | str = av_malloc(len + 1); | |
753 | ✗ | if (!str) | |
754 | ✗ | return NULL; | |
755 | ✗ | memcpy(str, p, len); | |
756 | ✗ | str[len] = '\0'; | |
757 | ✗ | p += len; | |
758 | ✗ | *pp = p; | |
759 | ✗ | return str; | |
760 | } | ||
761 | |||
762 | 6435 | static int parse_section_header(SectionHeader *h, | |
763 | const uint8_t **pp, const uint8_t *p_end) | ||
764 | { | ||
765 | int val; | ||
766 | |||
767 | 6435 | val = get8(pp, p_end); | |
768 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 6435 times.
|
6435 | if (val < 0) |
769 | ✗ | return val; | |
770 | 6435 | h->tid = val; | |
771 | 6435 | *pp += 2; | |
772 | 6435 | val = get16(pp, p_end); | |
773 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 6435 times.
|
6435 | if (val < 0) |
774 | ✗ | return val; | |
775 | 6435 | h->id = val; | |
776 | 6435 | val = get8(pp, p_end); | |
777 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 6435 times.
|
6435 | if (val < 0) |
778 | ✗ | return val; | |
779 | 6435 | h->version = (val >> 1) & 0x1f; | |
780 | 6435 | h->current_next = val & 0x01; | |
781 | 6435 | val = get8(pp, p_end); | |
782 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 6435 times.
|
6435 | if (val < 0) |
783 | ✗ | return val; | |
784 | 6435 | h->sec_num = val; | |
785 | 6435 | val = get8(pp, p_end); | |
786 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 6435 times.
|
6435 | if (val < 0) |
787 | ✗ | return val; | |
788 | 6435 | h->last_sec_num = val; | |
789 | 6435 | return 0; | |
790 | } | ||
791 | |||
792 | typedef struct StreamType { | ||
793 | uint32_t stream_type; | ||
794 | enum AVMediaType codec_type; | ||
795 | enum AVCodecID codec_id; | ||
796 | } StreamType; | ||
797 | |||
798 | static const StreamType ISO_types[] = { | ||
799 | { 0x01, AVMEDIA_TYPE_VIDEO, AV_CODEC_ID_MPEG2VIDEO }, | ||
800 | { 0x02, AVMEDIA_TYPE_VIDEO, AV_CODEC_ID_MPEG2VIDEO }, | ||
801 | { 0x03, AVMEDIA_TYPE_AUDIO, AV_CODEC_ID_MP3 }, | ||
802 | { 0x04, AVMEDIA_TYPE_AUDIO, AV_CODEC_ID_MP3 }, | ||
803 | { 0x0f, AVMEDIA_TYPE_AUDIO, AV_CODEC_ID_AAC }, | ||
804 | { 0x10, AVMEDIA_TYPE_VIDEO, AV_CODEC_ID_MPEG4 }, | ||
805 | /* Makito encoder sets stream type 0x11 for AAC, | ||
806 | * so auto-detect LOAS/LATM instead of hardcoding it. */ | ||
807 | #if !CONFIG_LOAS_DEMUXER | ||
808 | { 0x11, AVMEDIA_TYPE_AUDIO, AV_CODEC_ID_AAC_LATM }, /* LATM syntax */ | ||
809 | #endif | ||
810 | { 0x1b, AVMEDIA_TYPE_VIDEO, AV_CODEC_ID_H264 }, | ||
811 | { 0x1c, AVMEDIA_TYPE_AUDIO, AV_CODEC_ID_AAC }, | ||
812 | { 0x20, AVMEDIA_TYPE_VIDEO, AV_CODEC_ID_H264 }, | ||
813 | { 0x21, AVMEDIA_TYPE_VIDEO, AV_CODEC_ID_JPEG2000 }, | ||
814 | { 0x24, AVMEDIA_TYPE_VIDEO, AV_CODEC_ID_HEVC }, | ||
815 | { 0x42, AVMEDIA_TYPE_VIDEO, AV_CODEC_ID_CAVS }, | ||
816 | { 0xd1, AVMEDIA_TYPE_VIDEO, AV_CODEC_ID_DIRAC }, | ||
817 | { 0xd2, AVMEDIA_TYPE_VIDEO, AV_CODEC_ID_AVS2 }, | ||
818 | { 0xd4, AVMEDIA_TYPE_VIDEO, AV_CODEC_ID_AVS3 }, | ||
819 | { 0xea, AVMEDIA_TYPE_VIDEO, AV_CODEC_ID_VC1 }, | ||
820 | { 0 }, | ||
821 | }; | ||
822 | |||
823 | static const StreamType HDMV_types[] = { | ||
824 | { 0x80, AVMEDIA_TYPE_AUDIO, AV_CODEC_ID_PCM_BLURAY }, | ||
825 | { 0x81, AVMEDIA_TYPE_AUDIO, AV_CODEC_ID_AC3 }, | ||
826 | { 0x82, AVMEDIA_TYPE_AUDIO, AV_CODEC_ID_DTS }, | ||
827 | { 0x83, AVMEDIA_TYPE_AUDIO, AV_CODEC_ID_TRUEHD }, | ||
828 | { 0x84, AVMEDIA_TYPE_AUDIO, AV_CODEC_ID_EAC3 }, | ||
829 | { 0x85, AVMEDIA_TYPE_AUDIO, AV_CODEC_ID_DTS }, /* DTS HD */ | ||
830 | { 0x86, AVMEDIA_TYPE_AUDIO, AV_CODEC_ID_DTS }, /* DTS HD MASTER*/ | ||
831 | { 0xa1, AVMEDIA_TYPE_AUDIO, AV_CODEC_ID_EAC3 }, /* E-AC3 Secondary Audio */ | ||
832 | { 0xa2, AVMEDIA_TYPE_AUDIO, AV_CODEC_ID_DTS }, /* DTS Express Secondary Audio */ | ||
833 | { 0x90, AVMEDIA_TYPE_SUBTITLE, AV_CODEC_ID_HDMV_PGS_SUBTITLE }, | ||
834 | { 0x92, AVMEDIA_TYPE_SUBTITLE, AV_CODEC_ID_HDMV_TEXT_SUBTITLE }, | ||
835 | { 0 }, | ||
836 | }; | ||
837 | |||
838 | /* SCTE types */ | ||
839 | static const StreamType SCTE_types[] = { | ||
840 | { 0x86, AVMEDIA_TYPE_DATA, AV_CODEC_ID_SCTE_35 }, | ||
841 | { 0 }, | ||
842 | }; | ||
843 | |||
844 | /* ATSC ? */ | ||
845 | static const StreamType MISC_types[] = { | ||
846 | { 0x81, AVMEDIA_TYPE_AUDIO, AV_CODEC_ID_AC3 }, | ||
847 | { 0x8a, AVMEDIA_TYPE_AUDIO, AV_CODEC_ID_DTS }, | ||
848 | { 0 }, | ||
849 | }; | ||
850 | |||
851 | /* HLS Sample Encryption Types */ | ||
852 | static const StreamType HLS_SAMPLE_ENC_types[] = { | ||
853 | { 0xdb, AVMEDIA_TYPE_VIDEO, AV_CODEC_ID_H264}, | ||
854 | { 0xcf, AVMEDIA_TYPE_AUDIO, AV_CODEC_ID_AAC }, | ||
855 | { 0xc1, AVMEDIA_TYPE_AUDIO, AV_CODEC_ID_AC3 }, | ||
856 | { 0xc2, AVMEDIA_TYPE_AUDIO, AV_CODEC_ID_EAC3}, | ||
857 | { 0 }, | ||
858 | }; | ||
859 | |||
860 | static const StreamType REGD_types[] = { | ||
861 | { MKTAG('d', 'r', 'a', 'c'), AVMEDIA_TYPE_VIDEO, AV_CODEC_ID_DIRAC }, | ||
862 | { MKTAG('A', 'C', '-', '3'), AVMEDIA_TYPE_AUDIO, AV_CODEC_ID_AC3 }, | ||
863 | { MKTAG('A', 'C', '-', '4'), AVMEDIA_TYPE_AUDIO, AV_CODEC_ID_AC4 }, | ||
864 | { MKTAG('B', 'S', 'S', 'D'), AVMEDIA_TYPE_AUDIO, AV_CODEC_ID_S302M }, | ||
865 | { MKTAG('D', 'T', 'S', '1'), AVMEDIA_TYPE_AUDIO, AV_CODEC_ID_DTS }, | ||
866 | { MKTAG('D', 'T', 'S', '2'), AVMEDIA_TYPE_AUDIO, AV_CODEC_ID_DTS }, | ||
867 | { MKTAG('D', 'T', 'S', '3'), AVMEDIA_TYPE_AUDIO, AV_CODEC_ID_DTS }, | ||
868 | { MKTAG('E', 'A', 'C', '3'), AVMEDIA_TYPE_AUDIO, AV_CODEC_ID_EAC3 }, | ||
869 | { MKTAG('H', 'E', 'V', 'C'), AVMEDIA_TYPE_VIDEO, AV_CODEC_ID_HEVC }, | ||
870 | { MKTAG('K', 'L', 'V', 'A'), AVMEDIA_TYPE_DATA, AV_CODEC_ID_SMPTE_KLV }, | ||
871 | { MKTAG('V', 'A', 'N', 'C'), AVMEDIA_TYPE_DATA, AV_CODEC_ID_SMPTE_2038 }, | ||
872 | { MKTAG('I', 'D', '3', ' '), AVMEDIA_TYPE_DATA, AV_CODEC_ID_TIMED_ID3 }, | ||
873 | { MKTAG('V', 'C', '-', '1'), AVMEDIA_TYPE_VIDEO, AV_CODEC_ID_VC1 }, | ||
874 | { MKTAG('O', 'p', 'u', 's'), AVMEDIA_TYPE_AUDIO, AV_CODEC_ID_OPUS }, | ||
875 | { 0 }, | ||
876 | }; | ||
877 | |||
878 | static const StreamType METADATA_types[] = { | ||
879 | { MKTAG('K','L','V','A'), AVMEDIA_TYPE_DATA, AV_CODEC_ID_SMPTE_KLV }, | ||
880 | { MKTAG('I','D','3',' '), AVMEDIA_TYPE_DATA, AV_CODEC_ID_TIMED_ID3 }, | ||
881 | { 0 }, | ||
882 | }; | ||
883 | |||
884 | /* descriptor present */ | ||
885 | static const StreamType DESC_types[] = { | ||
886 | { 0x6a, AVMEDIA_TYPE_AUDIO, AV_CODEC_ID_AC3 }, /* AC-3 descriptor */ | ||
887 | { 0x7a, AVMEDIA_TYPE_AUDIO, AV_CODEC_ID_EAC3 }, /* E-AC-3 descriptor */ | ||
888 | { 0x7b, AVMEDIA_TYPE_AUDIO, AV_CODEC_ID_DTS }, | ||
889 | { 0x56, AVMEDIA_TYPE_SUBTITLE, AV_CODEC_ID_DVB_TELETEXT }, | ||
890 | { 0x59, AVMEDIA_TYPE_SUBTITLE, AV_CODEC_ID_DVB_SUBTITLE }, /* subtitling descriptor */ | ||
891 | { 0 }, | ||
892 | }; | ||
893 | |||
894 | 149 | static void mpegts_find_stream_type(AVStream *st, | |
895 | uint32_t stream_type, | ||
896 | const StreamType *types) | ||
897 | { | ||
898 | 149 | FFStream *const sti = ffstream(st); | |
899 |
2/2✓ Branch 0 taken 756 times.
✓ Branch 1 taken 47 times.
|
803 | for (; types->stream_type; types++) |
900 |
2/2✓ Branch 0 taken 102 times.
✓ Branch 1 taken 654 times.
|
756 | if (stream_type == types->stream_type) { |
901 |
2/2✓ Branch 0 taken 8 times.
✓ Branch 1 taken 94 times.
|
102 | if (st->codecpar->codec_type != types->codec_type || |
902 |
2/2✓ Branch 0 taken 7 times.
✓ Branch 1 taken 1 times.
|
8 | st->codecpar->codec_id != types->codec_id) { |
903 | 101 | st->codecpar->codec_type = types->codec_type; | |
904 | 101 | st->codecpar->codec_id = types->codec_id; | |
905 | 101 | sti->need_context_update = 1; | |
906 | } | ||
907 | 102 | sti->request_probe = 0; | |
908 | 102 | return; | |
909 | } | ||
910 | } | ||
911 | |||
912 | 97 | static int mpegts_set_stream_info(AVStream *st, PESContext *pes, | |
913 | uint32_t stream_type, uint32_t prog_reg_desc) | ||
914 | { | ||
915 | 97 | FFStream *const sti = ffstream(st); | |
916 | 97 | int old_codec_type = st->codecpar->codec_type; | |
917 | 97 | int old_codec_id = st->codecpar->codec_id; | |
918 | 97 | int old_codec_tag = st->codecpar->codec_tag; | |
919 | |||
920 |
1/2✗ Branch 1 not taken.
✓ Branch 2 taken 97 times.
|
97 | if (avcodec_is_open(sti->avctx)) { |
921 | ✗ | av_log(pes->stream, AV_LOG_DEBUG, "cannot set stream info, internal codec is open\n"); | |
922 | ✗ | return 0; | |
923 | } | ||
924 | |||
925 | 97 | avpriv_set_pts_info(st, 33, 1, 90000); | |
926 | 97 | st->priv_data = pes; | |
927 | 97 | st->codecpar->codec_type = AVMEDIA_TYPE_DATA; | |
928 | 97 | st->codecpar->codec_id = AV_CODEC_ID_NONE; | |
929 | 97 | sti->need_parsing = AVSTREAM_PARSE_FULL; | |
930 | 97 | pes->st = st; | |
931 | 97 | pes->stream_type = stream_type; | |
932 | |||
933 | 97 | av_log(pes->stream, AV_LOG_DEBUG, | |
934 | "stream=%d stream_type=%x pid=%x prog_reg_desc=%.4s\n", | ||
935 | st->index, pes->stream_type, pes->pid, (char *)&prog_reg_desc); | ||
936 | |||
937 | 97 | st->codecpar->codec_tag = pes->stream_type; | |
938 | |||
939 | 97 | mpegts_find_stream_type(st, pes->stream_type, ISO_types); | |
940 |
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) |
941 | 7 | sti->request_probe = 50; | |
942 |
1/2✓ Branch 0 taken 97 times.
✗ Branch 1 not taken.
|
97 | if ((prog_reg_desc == AV_RL32("HDMV") || |
943 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 97 times.
|
97 | prog_reg_desc == AV_RL32("HDPR")) && |
944 | ✗ | st->codecpar->codec_id == AV_CODEC_ID_NONE) { | |
945 | ✗ | mpegts_find_stream_type(st, pes->stream_type, HDMV_types); | |
946 | ✗ | if (pes->stream_type == 0x83) { | |
947 | // HDMV TrueHD streams also contain an AC3 coded version of the | ||
948 | // audio track - add a second stream for this | ||
949 | AVStream *sub_st; | ||
950 | // priv_data cannot be shared between streams | ||
951 | ✗ | PESContext *sub_pes = av_memdup(pes, sizeof(*sub_pes)); | |
952 | ✗ | if (!sub_pes) | |
953 | ✗ | return AVERROR(ENOMEM); | |
954 | |||
955 | ✗ | sub_st = avformat_new_stream(pes->stream, NULL); | |
956 | ✗ | if (!sub_st) { | |
957 | ✗ | av_free(sub_pes); | |
958 | ✗ | return AVERROR(ENOMEM); | |
959 | } | ||
960 | |||
961 | ✗ | sub_st->id = pes->pid; | |
962 | ✗ | avpriv_set_pts_info(sub_st, 33, 1, 90000); | |
963 | ✗ | sub_st->priv_data = sub_pes; | |
964 | ✗ | sub_st->codecpar->codec_type = AVMEDIA_TYPE_AUDIO; | |
965 | ✗ | sub_st->codecpar->codec_id = AV_CODEC_ID_AC3; | |
966 | ✗ | ffstream(sub_st)->need_parsing = AVSTREAM_PARSE_FULL; | |
967 | ✗ | sub_pes->sub_st = pes->sub_st = sub_st; | |
968 | } | ||
969 | } | ||
970 |
2/2✓ Branch 0 taken 23 times.
✓ Branch 1 taken 74 times.
|
97 | if (st->codecpar->codec_id == AV_CODEC_ID_NONE) |
971 | 23 | mpegts_find_stream_type(st, pes->stream_type, MISC_types); | |
972 |
2/2✓ Branch 0 taken 8 times.
✓ Branch 1 taken 89 times.
|
97 | if (st->codecpar->codec_id == AV_CODEC_ID_NONE) |
973 | 8 | mpegts_find_stream_type(st, pes->stream_type, HLS_SAMPLE_ENC_types); | |
974 |
2/2✓ Branch 0 taken 8 times.
✓ Branch 1 taken 89 times.
|
97 | if (st->codecpar->codec_id == AV_CODEC_ID_NONE) { |
975 | 8 | st->codecpar->codec_id = old_codec_id; | |
976 | 8 | st->codecpar->codec_type = old_codec_type; | |
977 | } | ||
978 |
2/2✓ Branch 0 taken 89 times.
✓ Branch 1 taken 8 times.
|
97 | if ((st->codecpar->codec_id == AV_CODEC_ID_NONE || |
979 |
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)) && |
980 |
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 && |
981 | stream_type == STREAM_TYPE_PRIVATE_DATA) { | ||
982 | 5 | st->codecpar->codec_type = AVMEDIA_TYPE_DATA; | |
983 | 5 | st->codecpar->codec_id = AV_CODEC_ID_BIN_DATA; | |
984 | 5 | sti->request_probe = AVPROBE_SCORE_STREAM_RETRY / 5; | |
985 | } | ||
986 | |||
987 | /* queue a context update if properties changed */ | ||
988 |
2/2✓ Branch 0 taken 3 times.
✓ Branch 1 taken 94 times.
|
97 | if (old_codec_type != st->codecpar->codec_type || |
989 |
1/2✓ Branch 0 taken 3 times.
✗ Branch 1 not taken.
|
3 | old_codec_id != st->codecpar->codec_id || |
990 |
1/2✓ Branch 0 taken 3 times.
✗ Branch 1 not taken.
|
3 | old_codec_tag != st->codecpar->codec_tag) |
991 | 97 | sti->need_context_update = 1; | |
992 | |||
993 | 97 | return 0; | |
994 | } | ||
995 | |||
996 | 55672 | static void reset_pes_packet_state(PESContext *pes) | |
997 | { | ||
998 | 55672 | pes->pts = AV_NOPTS_VALUE; | |
999 | 55672 | pes->dts = AV_NOPTS_VALUE; | |
1000 | 55672 | pes->data_index = 0; | |
1001 | 55672 | pes->flags = 0; | |
1002 | 55672 | av_buffer_unref(&pes->buffer); | |
1003 | 55672 | } | |
1004 | |||
1005 | 12 | static void new_data_packet(const uint8_t *buffer, int len, AVPacket *pkt) | |
1006 | { | ||
1007 | 12 | av_packet_unref(pkt); | |
1008 | 12 | pkt->data = (uint8_t *)buffer; | |
1009 | 12 | pkt->size = len; | |
1010 | 12 | } | |
1011 | |||
1012 | 28912 | static int new_pes_packet(PESContext *pes, AVPacket *pkt) | |
1013 | { | ||
1014 | uint8_t *sd; | ||
1015 | |||
1016 | 28912 | av_packet_unref(pkt); | |
1017 | |||
1018 | 28912 | pkt->buf = pes->buffer; | |
1019 | 28912 | pkt->data = pes->buffer->data; | |
1020 | 28912 | pkt->size = pes->data_index; | |
1021 | |||
1022 |
2/2✓ Branch 0 taken 26006 times.
✓ Branch 1 taken 2906 times.
|
28912 | if (pes->PES_packet_length && |
1023 |
2/2✓ Branch 0 taken 83 times.
✓ Branch 1 taken 25923 times.
|
26006 | pes->pes_header_size + pes->data_index != pes->PES_packet_length + |
1024 | PES_START_SIZE) { | ||
1025 | 83 | av_log(pes->stream, AV_LOG_WARNING, "PES packet size mismatch\n"); | |
1026 | 83 | pes->flags |= AV_PKT_FLAG_CORRUPT; | |
1027 | } | ||
1028 | 28912 | memset(pkt->data + pkt->size, 0, AV_INPUT_BUFFER_PADDING_SIZE); | |
1029 | |||
1030 | // Separate out the AC3 substream from an HDMV combined TrueHD/AC3 PID | ||
1031 |
1/6✗ Branch 0 not taken.
✓ Branch 1 taken 28912 times.
✗ Branch 2 not taken.
✗ Branch 3 not taken.
✗ Branch 4 not taken.
✗ Branch 5 not taken.
|
28912 | if (pes->sub_st && pes->stream_type == 0x83 && pes->extended_stream_id == 0x76) |
1032 | ✗ | pkt->stream_index = pes->sub_st->index; | |
1033 | else | ||
1034 | 28912 | pkt->stream_index = pes->st->index; | |
1035 | 28912 | pkt->pts = pes->pts; | |
1036 | 28912 | pkt->dts = pes->dts; | |
1037 | /* store position of first TS packet of this PES packet */ | ||
1038 | 28912 | pkt->pos = pes->ts_packet_pos; | |
1039 | 28912 | pkt->flags = pes->flags; | |
1040 | |||
1041 | 28912 | pes->buffer = NULL; | |
1042 | 28912 | reset_pes_packet_state(pes); | |
1043 | |||
1044 | 28912 | sd = av_packet_new_side_data(pkt, AV_PKT_DATA_MPEGTS_STREAM_ID, 1); | |
1045 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 28912 times.
|
28912 | if (!sd) |
1046 | ✗ | return AVERROR(ENOMEM); | |
1047 | 28912 | *sd = pes->stream_id; | |
1048 | |||
1049 | 28912 | return 0; | |
1050 | } | ||
1051 | |||
1052 | ✗ | static uint64_t get_ts64(GetBitContext *gb, int bits) | |
1053 | { | ||
1054 | ✗ | if (get_bits_left(gb) < bits) | |
1055 | ✗ | return AV_NOPTS_VALUE; | |
1056 | ✗ | return get_bits64(gb, bits); | |
1057 | } | ||
1058 | |||
1059 | ✗ | static int read_sl_header(PESContext *pes, SLConfigDescr *sl, | |
1060 | const uint8_t *buf, int buf_size) | ||
1061 | { | ||
1062 | GetBitContext gb; | ||
1063 | ✗ | int au_start_flag = 0, au_end_flag = 0, ocr_flag = 0, idle_flag = 0; | |
1064 | ✗ | int padding_flag = 0, padding_bits = 0, inst_bitrate_flag = 0; | |
1065 | ✗ | int dts_flag = -1, cts_flag = -1; | |
1066 | ✗ | int64_t dts = AV_NOPTS_VALUE, cts = AV_NOPTS_VALUE; | |
1067 | uint8_t buf_padded[128 + AV_INPUT_BUFFER_PADDING_SIZE]; | ||
1068 | ✗ | int buf_padded_size = FFMIN(buf_size, sizeof(buf_padded) - AV_INPUT_BUFFER_PADDING_SIZE); | |
1069 | |||
1070 | ✗ | memcpy(buf_padded, buf, buf_padded_size); | |
1071 | |||
1072 | ✗ | init_get_bits(&gb, buf_padded, buf_padded_size * 8); | |
1073 | |||
1074 | ✗ | if (sl->use_au_start) | |
1075 | ✗ | au_start_flag = get_bits1(&gb); | |
1076 | ✗ | if (sl->use_au_end) | |
1077 | ✗ | au_end_flag = get_bits1(&gb); | |
1078 | ✗ | if (!sl->use_au_start && !sl->use_au_end) | |
1079 | ✗ | au_start_flag = au_end_flag = 1; | |
1080 | ✗ | if (sl->ocr_len > 0) | |
1081 | ✗ | ocr_flag = get_bits1(&gb); | |
1082 | ✗ | if (sl->use_idle) | |
1083 | ✗ | idle_flag = get_bits1(&gb); | |
1084 | ✗ | if (sl->use_padding) | |
1085 | ✗ | padding_flag = get_bits1(&gb); | |
1086 | ✗ | if (padding_flag) | |
1087 | ✗ | padding_bits = get_bits(&gb, 3); | |
1088 | |||
1089 | ✗ | if (!idle_flag && (!padding_flag || padding_bits != 0)) { | |
1090 | ✗ | if (sl->packet_seq_num_len) | |
1091 | ✗ | skip_bits_long(&gb, sl->packet_seq_num_len); | |
1092 | ✗ | if (sl->degr_prior_len) | |
1093 | ✗ | if (get_bits1(&gb)) | |
1094 | ✗ | skip_bits(&gb, sl->degr_prior_len); | |
1095 | ✗ | if (ocr_flag) | |
1096 | ✗ | skip_bits_long(&gb, sl->ocr_len); | |
1097 | ✗ | if (au_start_flag) { | |
1098 | ✗ | if (sl->use_rand_acc_pt) | |
1099 | ✗ | get_bits1(&gb); | |
1100 | ✗ | if (sl->au_seq_num_len > 0) | |
1101 | ✗ | skip_bits_long(&gb, sl->au_seq_num_len); | |
1102 | ✗ | if (sl->use_timestamps) { | |
1103 | ✗ | dts_flag = get_bits1(&gb); | |
1104 | ✗ | cts_flag = get_bits1(&gb); | |
1105 | } | ||
1106 | } | ||
1107 | ✗ | if (sl->inst_bitrate_len) | |
1108 | ✗ | inst_bitrate_flag = get_bits1(&gb); | |
1109 | ✗ | if (dts_flag == 1) | |
1110 | ✗ | dts = get_ts64(&gb, sl->timestamp_len); | |
1111 | ✗ | if (cts_flag == 1) | |
1112 | ✗ | cts = get_ts64(&gb, sl->timestamp_len); | |
1113 | ✗ | if (sl->au_len > 0) | |
1114 | ✗ | skip_bits_long(&gb, sl->au_len); | |
1115 | ✗ | if (inst_bitrate_flag) | |
1116 | ✗ | skip_bits_long(&gb, sl->inst_bitrate_len); | |
1117 | } | ||
1118 | |||
1119 | ✗ | if (dts != AV_NOPTS_VALUE) | |
1120 | ✗ | pes->dts = dts; | |
1121 | ✗ | if (cts != AV_NOPTS_VALUE) | |
1122 | ✗ | pes->pts = cts; | |
1123 | |||
1124 | ✗ | if (sl->timestamp_len && sl->timestamp_res) | |
1125 | ✗ | avpriv_set_pts_info(pes->st, sl->timestamp_len, 1, sl->timestamp_res); | |
1126 | |||
1127 | ✗ | return (get_bits_count(&gb) + 7) >> 3; | |
1128 | } | ||
1129 | |||
1130 | 29008 | static AVBufferRef *buffer_pool_get(MpegTSContext *ts, int size) | |
1131 | { | ||
1132 | 29008 | int index = av_log2(size + AV_INPUT_BUFFER_PADDING_SIZE); | |
1133 |
2/2✓ Branch 0 taken 154 times.
✓ Branch 1 taken 28854 times.
|
29008 | if (!ts->pools[index]) { |
1134 |
2/2✓ Branch 0 taken 130 times.
✓ Branch 1 taken 24 times.
|
154 | int pool_size = FFMIN(ts->max_packet_size + AV_INPUT_BUFFER_PADDING_SIZE, 2 << index); |
1135 | 154 | ts->pools[index] = av_buffer_pool_init(pool_size, NULL); | |
1136 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 154 times.
|
154 | if (!ts->pools[index]) |
1137 | ✗ | return NULL; | |
1138 | } | ||
1139 | 29008 | return av_buffer_pool_get(ts->pools[index]); | |
1140 | } | ||
1141 | |||
1142 | /* return non zero if a packet could be constructed */ | ||
1143 | 365066 | static int mpegts_push_data(MpegTSFilter *filter, | |
1144 | const uint8_t *buf, int buf_size, int is_start, | ||
1145 | int64_t pos) | ||
1146 | { | ||
1147 | 365066 | PESContext *pes = filter->u.pes_filter.opaque; | |
1148 | 365066 | MpegTSContext *ts = pes->ts; | |
1149 | const uint8_t *p; | ||
1150 | int ret, len; | ||
1151 | |||
1152 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 365066 times.
|
365066 | if (!ts->pkt) |
1153 | ✗ | return 0; | |
1154 | |||
1155 |
2/2✓ Branch 0 taken 29598 times.
✓ Branch 1 taken 335468 times.
|
365066 | if (is_start) { |
1156 |
3/4✓ Branch 0 taken 2838 times.
✓ Branch 1 taken 26760 times.
✓ Branch 2 taken 2838 times.
✗ Branch 3 not taken.
|
29598 | if (pes->state == MPEGTS_PAYLOAD && pes->data_index > 0) { |
1157 | 2838 | ret = new_pes_packet(pes, ts->pkt); | |
1158 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 2838 times.
|
2838 | if (ret < 0) |
1159 | ✗ | return ret; | |
1160 | 2838 | ts->stop_parse = 1; | |
1161 | } else { | ||
1162 | 26760 | reset_pes_packet_state(pes); | |
1163 | } | ||
1164 | 29598 | pes->state = MPEGTS_HEADER; | |
1165 | 29598 | pes->ts_packet_pos = pos; | |
1166 | } | ||
1167 | 365066 | p = buf; | |
1168 |
2/2✓ Branch 0 taken 452678 times.
✓ Branch 1 taken 365066 times.
|
1182810 | while (buf_size > 0) { |
1169 |
5/6✓ Branch 0 taken 29598 times.
✓ Branch 1 taken 29008 times.
✓ Branch 2 taken 29008 times.
✓ Branch 3 taken 349256 times.
✓ Branch 4 taken 15808 times.
✗ Branch 5 not taken.
|
452678 | switch (pes->state) { |
1170 | 29598 | case MPEGTS_HEADER: | |
1171 | 29598 | len = PES_START_SIZE - pes->data_index; | |
1172 |
2/2✓ Branch 0 taken 2 times.
✓ Branch 1 taken 29596 times.
|
29598 | if (len > buf_size) |
1173 | 2 | len = buf_size; | |
1174 | 29598 | memcpy(pes->header + pes->data_index, p, len); | |
1175 | 29598 | pes->data_index += len; | |
1176 | 29598 | p += len; | |
1177 | 29598 | buf_size -= len; | |
1178 |
2/2✓ Branch 0 taken 29596 times.
✓ Branch 1 taken 2 times.
|
29598 | if (pes->data_index == PES_START_SIZE) { |
1179 | /* we got all the PES or section header. We can now | ||
1180 | * decide */ | ||
1181 |
3/4✓ Branch 0 taken 29589 times.
✓ Branch 1 taken 7 times.
✗ Branch 2 not taken.
✓ Branch 3 taken 29589 times.
|
29596 | if (pes->header[0] == 0x00 && pes->header[1] == 0x00 && |
1182 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 29589 times.
|
29589 | pes->header[2] == 0x01) { |
1183 | /* it must be an MPEG-2 PES stream */ | ||
1184 | 29589 | pes->stream_id = pes->header[3]; | |
1185 | 29589 | av_log(pes->stream, AV_LOG_TRACE, "pid=%x stream_id=%#x\n", pes->pid, pes->stream_id); | |
1186 | |||
1187 |
3/4✓ Branch 0 taken 29589 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 581 times.
✓ Branch 3 taken 29008 times.
|
29589 | if ((pes->st && pes->st->discard == AVDISCARD_ALL && |
1188 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 581 times.
|
581 | (!pes->sub_st || |
1189 | ✗ | pes->sub_st->discard == AVDISCARD_ALL)) || | |
1190 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 29008 times.
|
29008 | pes->stream_id == STREAM_ID_PADDING_STREAM) |
1191 | 581 | goto skip; | |
1192 | |||
1193 | /* stream not present in PMT */ | ||
1194 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 29008 times.
|
29008 | if (!pes->st) { |
1195 | ✗ | if (ts->skip_changes) | |
1196 | ✗ | goto skip; | |
1197 | ✗ | if (ts->merge_pmt_versions) | |
1198 | ✗ | goto skip; /* wait for PMT to merge new stream */ | |
1199 | |||
1200 | ✗ | pes->st = avformat_new_stream(ts->stream, NULL); | |
1201 | ✗ | if (!pes->st) | |
1202 | ✗ | return AVERROR(ENOMEM); | |
1203 | ✗ | pes->st->id = pes->pid; | |
1204 | ✗ | mpegts_set_stream_info(pes->st, pes, 0, 0); | |
1205 | } | ||
1206 | |||
1207 | 29008 | pes->PES_packet_length = AV_RB16(pes->header + 4); | |
1208 | /* NOTE: zero length means the PES size is unbounded */ | ||
1209 | |||
1210 |
1/2✓ Branch 0 taken 29008 times.
✗ Branch 1 not taken.
|
29008 | if (pes->stream_id != STREAM_ID_PROGRAM_STREAM_MAP && |
1211 |
1/2✓ Branch 0 taken 29008 times.
✗ Branch 1 not taken.
|
29008 | pes->stream_id != STREAM_ID_PRIVATE_STREAM_2 && |
1212 |
1/2✓ Branch 0 taken 29008 times.
✗ Branch 1 not taken.
|
29008 | pes->stream_id != STREAM_ID_ECM_STREAM && |
1213 |
1/2✓ Branch 0 taken 29008 times.
✗ Branch 1 not taken.
|
29008 | pes->stream_id != STREAM_ID_EMM_STREAM && |
1214 |
1/2✓ Branch 0 taken 29008 times.
✗ Branch 1 not taken.
|
29008 | pes->stream_id != STREAM_ID_PROGRAM_STREAM_DIRECTORY && |
1215 |
1/2✓ Branch 0 taken 29008 times.
✗ Branch 1 not taken.
|
29008 | pes->stream_id != STREAM_ID_DSMCC_STREAM && |
1216 |
1/2✓ Branch 0 taken 29008 times.
✗ Branch 1 not taken.
|
58016 | pes->stream_id != STREAM_ID_TYPE_E_STREAM) { |
1217 | 29008 | FFStream *const pes_sti = ffstream(pes->st); | |
1218 | 29008 | pes->state = MPEGTS_PESHEADER; | |
1219 |
3/4✓ Branch 0 taken 2 times.
✓ Branch 1 taken 29006 times.
✓ Branch 2 taken 2 times.
✗ Branch 3 not taken.
|
29008 | if (pes->st->codecpar->codec_id == AV_CODEC_ID_NONE && !pes_sti->request_probe) { |
1220 | 2 | av_log(pes->stream, AV_LOG_TRACE, | |
1221 | "pid=%x stream_type=%x probing\n", | ||
1222 | pes->pid, | ||
1223 | pes->stream_type); | ||
1224 | 2 | pes_sti->request_probe = 1; | |
1225 | } | ||
1226 | } else { | ||
1227 | ✗ | pes->pes_header_size = 6; | |
1228 | ✗ | pes->state = MPEGTS_PAYLOAD; | |
1229 | ✗ | pes->data_index = 0; | |
1230 | } | ||
1231 | } else { | ||
1232 | /* otherwise, it should be a table */ | ||
1233 | /* skip packet */ | ||
1234 | 7 | skip: | |
1235 | 588 | pes->state = MPEGTS_SKIP; | |
1236 | 588 | continue; | |
1237 | } | ||
1238 | } | ||
1239 | 29010 | break; | |
1240 | /**********************************************/ | ||
1241 | /* PES packing parsing */ | ||
1242 | 29008 | case MPEGTS_PESHEADER: | |
1243 | 29008 | len = PES_HEADER_SIZE - pes->data_index; | |
1244 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 29008 times.
|
29008 | if (len < 0) |
1245 | ✗ | return AVERROR_INVALIDDATA; | |
1246 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 29008 times.
|
29008 | if (len > buf_size) |
1247 | ✗ | len = buf_size; | |
1248 | 29008 | memcpy(pes->header + pes->data_index, p, len); | |
1249 | 29008 | pes->data_index += len; | |
1250 | 29008 | p += len; | |
1251 | 29008 | buf_size -= len; | |
1252 |
1/2✓ Branch 0 taken 29008 times.
✗ Branch 1 not taken.
|
29008 | if (pes->data_index == PES_HEADER_SIZE) { |
1253 | 29008 | pes->pes_header_size = pes->header[8] + 9; | |
1254 | 29008 | pes->state = MPEGTS_PESHEADER_FILL; | |
1255 | } | ||
1256 | 29008 | break; | |
1257 | 29008 | case MPEGTS_PESHEADER_FILL: | |
1258 | 29008 | len = pes->pes_header_size - pes->data_index; | |
1259 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 29008 times.
|
29008 | if (len < 0) |
1260 | ✗ | return AVERROR_INVALIDDATA; | |
1261 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 29008 times.
|
29008 | if (len > buf_size) |
1262 | ✗ | len = buf_size; | |
1263 | 29008 | memcpy(pes->header + pes->data_index, p, len); | |
1264 | 29008 | pes->data_index += len; | |
1265 | 29008 | p += len; | |
1266 | 29008 | buf_size -= len; | |
1267 |
1/2✓ Branch 0 taken 29008 times.
✗ Branch 1 not taken.
|
29008 | if (pes->data_index == pes->pes_header_size) { |
1268 | const uint8_t *r; | ||
1269 | unsigned int flags, pes_ext, skip; | ||
1270 | |||
1271 | 29008 | flags = pes->header[7]; | |
1272 | 29008 | r = pes->header + 9; | |
1273 | 29008 | pes->pts = AV_NOPTS_VALUE; | |
1274 | 29008 | pes->dts = AV_NOPTS_VALUE; | |
1275 |
2/2✓ Branch 0 taken 10419 times.
✓ Branch 1 taken 18589 times.
|
29008 | if ((flags & 0xc0) == 0x80) { |
1276 | 10419 | pes->dts = pes->pts = ff_parse_pes_pts(r); | |
1277 | 10419 | r += 5; | |
1278 |
2/2✓ Branch 0 taken 1840 times.
✓ Branch 1 taken 16749 times.
|
18589 | } else if ((flags & 0xc0) == 0xc0) { |
1279 | 1840 | pes->pts = ff_parse_pes_pts(r); | |
1280 | 1840 | r += 5; | |
1281 | 1840 | pes->dts = ff_parse_pes_pts(r); | |
1282 | 1840 | r += 5; | |
1283 | } | ||
1284 | 29008 | pes->extended_stream_id = -1; | |
1285 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 29008 times.
|
29008 | if (flags & 0x01) { /* PES extension */ |
1286 | ✗ | pes_ext = *r++; | |
1287 | /* Skip PES private data, program packet sequence counter and P-STD buffer */ | ||
1288 | ✗ | skip = (pes_ext >> 4) & 0xb; | |
1289 | ✗ | skip += skip & 0x9; | |
1290 | ✗ | r += skip; | |
1291 | ✗ | if ((pes_ext & 0x41) == 0x01 && | |
1292 | ✗ | (r + 2) <= (pes->header + pes->pes_header_size)) { | |
1293 | /* PES extension 2 */ | ||
1294 | ✗ | if ((r[0] & 0x7f) > 0 && (r[1] & 0x80) == 0) | |
1295 | ✗ | pes->extended_stream_id = r[1]; | |
1296 | } | ||
1297 | } | ||
1298 | |||
1299 | /* we got the full header. We parse it and get the payload */ | ||
1300 | 29008 | pes->state = MPEGTS_PAYLOAD; | |
1301 | 29008 | pes->data_index = 0; | |
1302 |
1/4✗ Branch 0 not taken.
✓ Branch 1 taken 29008 times.
✗ Branch 2 not taken.
✗ Branch 3 not taken.
|
29008 | if (pes->stream_type == 0x12 && buf_size > 0) { |
1303 | ✗ | int sl_header_bytes = read_sl_header(pes, &pes->sl, p, | |
1304 | buf_size); | ||
1305 | ✗ | pes->pes_header_size += sl_header_bytes; | |
1306 | ✗ | p += sl_header_bytes; | |
1307 | ✗ | buf_size -= sl_header_bytes; | |
1308 | } | ||
1309 |
1/4✗ Branch 0 not taken.
✓ Branch 1 taken 29008 times.
✗ Branch 2 not taken.
✗ Branch 3 not taken.
|
29008 | if (pes->st->codecpar->codec_id == AV_CODEC_ID_SMPTE_KLV && buf_size >= 5) { |
1310 | /* skip metadata access unit header */ | ||
1311 | ✗ | pes->pes_header_size += 5; | |
1312 | ✗ | p += 5; | |
1313 | ✗ | buf_size -= 5; | |
1314 | } | ||
1315 |
1/2✓ Branch 0 taken 29008 times.
✗ Branch 1 not taken.
|
29008 | if ( pes->ts->fix_teletext_pts |
1316 |
1/2✓ Branch 0 taken 29008 times.
✗ Branch 1 not taken.
|
29008 | && ( pes->st->codecpar->codec_id == AV_CODEC_ID_DVB_TELETEXT |
1317 |
2/2✓ Branch 0 taken 254 times.
✓ Branch 1 taken 28754 times.
|
29008 | || pes->st->codecpar->codec_id == AV_CODEC_ID_DVB_SUBTITLE) |
1318 | ) { | ||
1319 | 254 | AVProgram *p = NULL; | |
1320 | 254 | int pcr_found = 0; | |
1321 |
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))) { |
1322 |
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) { |
1323 | 254 | MpegTSFilter *f = pes->ts->pids[p->pcr_pid]; | |
1324 |
1/2✓ Branch 0 taken 254 times.
✗ Branch 1 not taken.
|
254 | if (f) { |
1325 | 254 | AVStream *st = NULL; | |
1326 |
1/2✓ Branch 0 taken 254 times.
✗ Branch 1 not taken.
|
254 | if (f->type == MPEGTS_PES) { |
1327 | 254 | PESContext *pcrpes = f->u.pes_filter.opaque; | |
1328 |
1/2✓ Branch 0 taken 254 times.
✗ Branch 1 not taken.
|
254 | if (pcrpes) |
1329 | 254 | st = pcrpes->st; | |
1330 | ✗ | } else if (f->type == MPEGTS_PCR) { | |
1331 | int i; | ||
1332 | ✗ | for (i = 0; i < p->nb_stream_indexes; i++) { | |
1333 | ✗ | AVStream *pst = pes->stream->streams[p->stream_index[i]]; | |
1334 | ✗ | if (pst->codecpar->codec_type == AVMEDIA_TYPE_VIDEO) | |
1335 | ✗ | st = pst; | |
1336 | } | ||
1337 | } | ||
1338 |
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) { |
1339 | // teletext packets do not always have correct timestamps, | ||
1340 | // the standard says they should be handled after 40.6 ms at most, | ||
1341 | // and the pcr error to this packet should be no more than 100 ms. | ||
1342 | // TODO: we should interpolate the PCR, not just use the last one | ||
1343 | ✗ | int64_t pcr = f->last_pcr / 300; | |
1344 | ✗ | pcr_found = 1; | |
1345 | ✗ | if (st) { | |
1346 | ✗ | const FFStream *const sti = ffstream(st); | |
1347 | ✗ | FFStream *const pes_sti = ffstream(pes->st); | |
1348 | |||
1349 | ✗ | pes_sti->pts_wrap_reference = sti->pts_wrap_reference; | |
1350 | ✗ | pes_sti->pts_wrap_behavior = sti->pts_wrap_behavior; | |
1351 | } | ||
1352 | ✗ | if (pes->dts == AV_NOPTS_VALUE || pes->dts < pcr) { | |
1353 | ✗ | pes->pts = pes->dts = pcr; | |
1354 | ✗ | } else if (pes->st->codecpar->codec_id == AV_CODEC_ID_DVB_TELETEXT && | |
1355 | ✗ | pes->dts > pcr + 3654 + 9000) { | |
1356 | ✗ | pes->pts = pes->dts = pcr + 3654 + 9000; | |
1357 | ✗ | } else if (pes->st->codecpar->codec_id == AV_CODEC_ID_DVB_SUBTITLE && | |
1358 | ✗ | pes->dts > pcr + 10*90000) { //10sec | |
1359 | ✗ | pes->pts = pes->dts = pcr + 3654 + 9000; | |
1360 | } | ||
1361 | ✗ | break; | |
1362 | } | ||
1363 | } | ||
1364 | } | ||
1365 | } | ||
1366 | |||
1367 |
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 && |
1368 | !pcr_found) { | ||
1369 | ✗ | av_log(pes->stream, AV_LOG_VERBOSE, | |
1370 | "Forcing DTS/PTS to be unset for a " | ||
1371 | "non-trustworthy PES packet for PID %d as " | ||
1372 | "PCR hasn't been received yet.\n", | ||
1373 | pes->pid); | ||
1374 | ✗ | pes->dts = pes->pts = AV_NOPTS_VALUE; | |
1375 | } | ||
1376 | } | ||
1377 | } | ||
1378 | 29008 | break; | |
1379 | 349256 | case MPEGTS_PAYLOAD: | |
1380 | do { | ||
1381 | 349256 | int max_packet_size = ts->max_packet_size; | |
1382 |
3/4✓ Branch 0 taken 193196 times.
✓ Branch 1 taken 156060 times.
✓ Branch 2 taken 193196 times.
✗ Branch 3 not taken.
|
349256 | if (pes->PES_packet_length && pes->PES_packet_length + PES_START_SIZE > pes->pes_header_size) |
1383 | 193196 | max_packet_size = pes->PES_packet_length + PES_START_SIZE - pes->pes_header_size; | |
1384 | |||
1385 |
2/2✓ Branch 0 taken 320248 times.
✓ Branch 1 taken 29008 times.
|
349256 | if (pes->data_index > 0 && |
1386 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 320248 times.
|
320248 | pes->data_index + buf_size > max_packet_size) { |
1387 | ✗ | ret = new_pes_packet(pes, ts->pkt); | |
1388 | ✗ | if (ret < 0) | |
1389 | ✗ | return ret; | |
1390 | ✗ | pes->PES_packet_length = 0; | |
1391 | ✗ | max_packet_size = ts->max_packet_size; | |
1392 | ✗ | ts->stop_parse = 1; | |
1393 |
3/4✓ Branch 0 taken 29008 times.
✓ Branch 1 taken 320248 times.
✗ Branch 2 not taken.
✓ Branch 3 taken 29008 times.
|
349256 | } else if (pes->data_index == 0 && |
1394 | buf_size > max_packet_size) { | ||
1395 | // pes packet size is < ts size packet and pes data is padded with 0xff | ||
1396 | // not sure if this is legal in ts but see issue #2392 | ||
1397 | ✗ | buf_size = max_packet_size; | |
1398 | } | ||
1399 | |||
1400 |
2/2✓ Branch 0 taken 29008 times.
✓ Branch 1 taken 320248 times.
|
349256 | if (!pes->buffer) { |
1401 | 29008 | pes->buffer = buffer_pool_get(ts, max_packet_size); | |
1402 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 29008 times.
|
29008 | if (!pes->buffer) |
1403 | ✗ | return AVERROR(ENOMEM); | |
1404 | } | ||
1405 | |||
1406 | 349256 | memcpy(pes->buffer->data + pes->data_index, p, buf_size); | |
1407 | 349256 | pes->data_index += buf_size; | |
1408 | /* emit complete packets with known packet size | ||
1409 | * decreases demuxer delay for infrequent packets like subtitles from | ||
1410 | * a couple of seconds to milliseconds for properly muxed files. */ | ||
1411 |
4/4✓ Branch 0 taken 346418 times.
✓ Branch 1 taken 2838 times.
✓ Branch 2 taken 193196 times.
✓ Branch 3 taken 153222 times.
|
349256 | if (!ts->stop_parse && pes->PES_packet_length && |
1412 |
2/2✓ Branch 0 taken 25923 times.
✓ Branch 1 taken 167273 times.
|
193196 | pes->pes_header_size + pes->data_index == pes->PES_packet_length + PES_START_SIZE) { |
1413 | 25923 | ts->stop_parse = 1; | |
1414 | 25923 | ret = new_pes_packet(pes, ts->pkt); | |
1415 | 25923 | pes->state = MPEGTS_SKIP; | |
1416 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 25923 times.
|
25923 | if (ret < 0) |
1417 | ✗ | return ret; | |
1418 | } | ||
1419 | } while (0); | ||
1420 | 349256 | buf_size = 0; | |
1421 | 349256 | break; | |
1422 | 15808 | case MPEGTS_SKIP: | |
1423 | 15808 | buf_size = 0; | |
1424 | 15808 | break; | |
1425 | } | ||
1426 | } | ||
1427 | |||
1428 | 365066 | return 0; | |
1429 | } | ||
1430 | |||
1431 | 118 | static PESContext *add_pes_stream(MpegTSContext *ts, int pid, int pcr_pid) | |
1432 | { | ||
1433 | MpegTSFilter *tss; | ||
1434 | PESContext *pes; | ||
1435 | |||
1436 | /* if no pid found, then add a pid context */ | ||
1437 | 118 | pes = av_mallocz(sizeof(PESContext)); | |
1438 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 118 times.
|
118 | if (!pes) |
1439 | ✗ | return 0; | |
1440 | 118 | pes->ts = ts; | |
1441 | 118 | pes->stream = ts->stream; | |
1442 | 118 | pes->pid = pid; | |
1443 | 118 | pes->pcr_pid = pcr_pid; | |
1444 | 118 | pes->state = MPEGTS_SKIP; | |
1445 | 118 | pes->pts = AV_NOPTS_VALUE; | |
1446 | 118 | pes->dts = AV_NOPTS_VALUE; | |
1447 | 118 | tss = mpegts_open_pes_filter(ts, pid, mpegts_push_data, pes); | |
1448 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 118 times.
|
118 | if (!tss) { |
1449 | ✗ | av_free(pes); | |
1450 | ✗ | return 0; | |
1451 | } | ||
1452 | 118 | return pes; | |
1453 | } | ||
1454 | |||
1455 | #define MAX_LEVEL 4 | ||
1456 | typedef struct MP4DescrParseContext { | ||
1457 | AVFormatContext *s; | ||
1458 | FFIOContext pb; | ||
1459 | Mp4Descr *descr; | ||
1460 | Mp4Descr *active_descr; | ||
1461 | int descr_count; | ||
1462 | int max_descr_count; | ||
1463 | int level; | ||
1464 | int predefined_SLConfigDescriptor_seen; | ||
1465 | } MP4DescrParseContext; | ||
1466 | |||
1467 | ✗ | static int init_MP4DescrParseContext(MP4DescrParseContext *d, AVFormatContext *s, | |
1468 | const uint8_t *buf, unsigned size, | ||
1469 | Mp4Descr *descr, int max_descr_count) | ||
1470 | { | ||
1471 | ✗ | if (size > (1 << 30)) | |
1472 | ✗ | return AVERROR_INVALIDDATA; | |
1473 | |||
1474 | ✗ | ffio_init_read_context(&d->pb, buf, size); | |
1475 | |||
1476 | ✗ | d->s = s; | |
1477 | ✗ | d->level = 0; | |
1478 | ✗ | d->descr_count = 0; | |
1479 | ✗ | d->descr = descr; | |
1480 | ✗ | d->active_descr = NULL; | |
1481 | ✗ | d->max_descr_count = max_descr_count; | |
1482 | |||
1483 | ✗ | return 0; | |
1484 | } | ||
1485 | |||
1486 | ✗ | static void update_offsets(AVIOContext *pb, int64_t *off, int *len) | |
1487 | { | ||
1488 | ✗ | int64_t new_off = avio_tell(pb); | |
1489 | ✗ | (*len) -= new_off - *off; | |
1490 | ✗ | *off = new_off; | |
1491 | ✗ | } | |
1492 | |||
1493 | static int parse_mp4_descr(MP4DescrParseContext *d, int64_t off, int len, | ||
1494 | int target_tag); | ||
1495 | |||
1496 | ✗ | static int parse_mp4_descr_arr(MP4DescrParseContext *d, int64_t off, int len) | |
1497 | { | ||
1498 | ✗ | while (len > 0) { | |
1499 | ✗ | int ret = parse_mp4_descr(d, off, len, 0); | |
1500 | ✗ | if (ret < 0) | |
1501 | ✗ | return ret; | |
1502 | ✗ | update_offsets(&d->pb.pub, &off, &len); | |
1503 | } | ||
1504 | ✗ | return 0; | |
1505 | } | ||
1506 | |||
1507 | ✗ | static int parse_MP4IODescrTag(MP4DescrParseContext *d, int64_t off, int len) | |
1508 | { | ||
1509 | ✗ | AVIOContext *const pb = &d->pb.pub; | |
1510 | ✗ | avio_rb16(pb); // ID | |
1511 | ✗ | avio_r8(pb); | |
1512 | ✗ | avio_r8(pb); | |
1513 | ✗ | avio_r8(pb); | |
1514 | ✗ | avio_r8(pb); | |
1515 | ✗ | avio_r8(pb); | |
1516 | ✗ | update_offsets(pb, &off, &len); | |
1517 | ✗ | return parse_mp4_descr_arr(d, off, len); | |
1518 | } | ||
1519 | |||
1520 | ✗ | static int parse_MP4ODescrTag(MP4DescrParseContext *d, int64_t off, int len) | |
1521 | { | ||
1522 | int id_flags; | ||
1523 | ✗ | if (len < 2) | |
1524 | ✗ | return 0; | |
1525 | ✗ | id_flags = avio_rb16(&d->pb.pub); | |
1526 | ✗ | if (!(id_flags & 0x0020)) { // URL_Flag | |
1527 | ✗ | update_offsets(&d->pb.pub, &off, &len); | |
1528 | ✗ | return parse_mp4_descr_arr(d, off, len); // ES_Descriptor[] | |
1529 | } else { | ||
1530 | ✗ | return 0; | |
1531 | } | ||
1532 | } | ||
1533 | |||
1534 | ✗ | static int parse_MP4ESDescrTag(MP4DescrParseContext *d, int64_t off, int len) | |
1535 | { | ||
1536 | ✗ | AVIOContext *const pb = &d->pb.pub; | |
1537 | ✗ | int es_id = 0; | |
1538 | ✗ | int ret = 0; | |
1539 | |||
1540 | ✗ | if (d->descr_count >= d->max_descr_count) | |
1541 | ✗ | return AVERROR_INVALIDDATA; | |
1542 | ✗ | ff_mp4_parse_es_descr(pb, &es_id); | |
1543 | ✗ | d->active_descr = d->descr + (d->descr_count++); | |
1544 | |||
1545 | ✗ | d->active_descr->es_id = es_id; | |
1546 | ✗ | update_offsets(pb, &off, &len); | |
1547 | ✗ | if ((ret = parse_mp4_descr(d, off, len, MP4DecConfigDescrTag)) < 0) | |
1548 | ✗ | return ret; | |
1549 | ✗ | update_offsets(pb, &off, &len); | |
1550 | ✗ | if (len > 0) | |
1551 | ✗ | ret = parse_mp4_descr(d, off, len, MP4SLDescrTag); | |
1552 | ✗ | d->active_descr = NULL; | |
1553 | ✗ | return ret; | |
1554 | } | ||
1555 | |||
1556 | ✗ | static int parse_MP4DecConfigDescrTag(MP4DescrParseContext *d, int64_t off, | |
1557 | int len) | ||
1558 | { | ||
1559 | ✗ | Mp4Descr *descr = d->active_descr; | |
1560 | ✗ | if (!descr) | |
1561 | ✗ | return AVERROR_INVALIDDATA; | |
1562 | ✗ | d->active_descr->dec_config_descr = av_malloc(len); | |
1563 | ✗ | if (!descr->dec_config_descr) | |
1564 | ✗ | return AVERROR(ENOMEM); | |
1565 | ✗ | descr->dec_config_descr_len = len; | |
1566 | ✗ | avio_read(&d->pb.pub, descr->dec_config_descr, len); | |
1567 | ✗ | return 0; | |
1568 | } | ||
1569 | |||
1570 | ✗ | static int parse_MP4SLDescrTag(MP4DescrParseContext *d, int64_t off, int len) | |
1571 | { | ||
1572 | ✗ | Mp4Descr *descr = d->active_descr; | |
1573 | ✗ | AVIOContext *const pb = &d->pb.pub; | |
1574 | int predefined; | ||
1575 | ✗ | if (!descr) | |
1576 | ✗ | return AVERROR_INVALIDDATA; | |
1577 | |||
1578 | #define R8_CHECK_CLIP_MAX(dst, maxv) do { \ | ||
1579 | descr->sl.dst = avio_r8(pb); \ | ||
1580 | if (descr->sl.dst > maxv) { \ | ||
1581 | descr->sl.dst = maxv; \ | ||
1582 | return AVERROR_INVALIDDATA; \ | ||
1583 | } \ | ||
1584 | } while (0) | ||
1585 | |||
1586 | ✗ | predefined = avio_r8(pb); | |
1587 | ✗ | if (!predefined) { | |
1588 | int lengths; | ||
1589 | ✗ | int flags = avio_r8(pb); | |
1590 | ✗ | descr->sl.use_au_start = !!(flags & 0x80); | |
1591 | ✗ | descr->sl.use_au_end = !!(flags & 0x40); | |
1592 | ✗ | descr->sl.use_rand_acc_pt = !!(flags & 0x20); | |
1593 | ✗ | descr->sl.use_padding = !!(flags & 0x08); | |
1594 | ✗ | descr->sl.use_timestamps = !!(flags & 0x04); | |
1595 | ✗ | descr->sl.use_idle = !!(flags & 0x02); | |
1596 | ✗ | descr->sl.timestamp_res = avio_rb32(pb); | |
1597 | ✗ | avio_rb32(pb); | |
1598 | ✗ | R8_CHECK_CLIP_MAX(timestamp_len, 63); | |
1599 | ✗ | R8_CHECK_CLIP_MAX(ocr_len, 63); | |
1600 | ✗ | R8_CHECK_CLIP_MAX(au_len, 31); | |
1601 | ✗ | descr->sl.inst_bitrate_len = avio_r8(pb); | |
1602 | ✗ | lengths = avio_rb16(pb); | |
1603 | ✗ | descr->sl.degr_prior_len = lengths >> 12; | |
1604 | ✗ | descr->sl.au_seq_num_len = (lengths >> 7) & 0x1f; | |
1605 | ✗ | descr->sl.packet_seq_num_len = (lengths >> 2) & 0x1f; | |
1606 | ✗ | } else if (!d->predefined_SLConfigDescriptor_seen){ | |
1607 | ✗ | avpriv_report_missing_feature(d->s, "Predefined SLConfigDescriptor"); | |
1608 | ✗ | d->predefined_SLConfigDescriptor_seen = 1; | |
1609 | } | ||
1610 | ✗ | return 0; | |
1611 | } | ||
1612 | |||
1613 | ✗ | static int parse_mp4_descr(MP4DescrParseContext *d, int64_t off, int len, | |
1614 | int target_tag) | ||
1615 | { | ||
1616 | int tag; | ||
1617 | ✗ | AVIOContext *const pb = &d->pb.pub; | |
1618 | ✗ | int len1 = ff_mp4_read_descr(d->s, pb, &tag); | |
1619 | ✗ | int ret = 0; | |
1620 | |||
1621 | ✗ | update_offsets(pb, &off, &len); | |
1622 | ✗ | if (len < 0 || len1 > len || len1 <= 0) { | |
1623 | ✗ | av_log(d->s, AV_LOG_ERROR, | |
1624 | "Tag %x length violation new length %d bytes remaining %d\n", | ||
1625 | tag, len1, len); | ||
1626 | ✗ | return AVERROR_INVALIDDATA; | |
1627 | } | ||
1628 | |||
1629 | ✗ | if (d->level++ >= MAX_LEVEL) { | |
1630 | ✗ | av_log(d->s, AV_LOG_ERROR, "Maximum MP4 descriptor level exceeded\n"); | |
1631 | ✗ | ret = AVERROR_INVALIDDATA; | |
1632 | ✗ | goto done; | |
1633 | } | ||
1634 | |||
1635 | ✗ | if (target_tag && tag != target_tag) { | |
1636 | ✗ | av_log(d->s, AV_LOG_ERROR, "Found tag %x expected %x\n", tag, | |
1637 | target_tag); | ||
1638 | ✗ | ret = AVERROR_INVALIDDATA; | |
1639 | ✗ | goto done; | |
1640 | } | ||
1641 | |||
1642 | ✗ | switch (tag) { | |
1643 | ✗ | case MP4IODescrTag: | |
1644 | ✗ | ret = parse_MP4IODescrTag(d, off, len1); | |
1645 | ✗ | break; | |
1646 | ✗ | case MP4ODescrTag: | |
1647 | ✗ | ret = parse_MP4ODescrTag(d, off, len1); | |
1648 | ✗ | break; | |
1649 | ✗ | case MP4ESDescrTag: | |
1650 | ✗ | ret = parse_MP4ESDescrTag(d, off, len1); | |
1651 | ✗ | break; | |
1652 | ✗ | case MP4DecConfigDescrTag: | |
1653 | ✗ | ret = parse_MP4DecConfigDescrTag(d, off, len1); | |
1654 | ✗ | break; | |
1655 | ✗ | case MP4SLDescrTag: | |
1656 | ✗ | ret = parse_MP4SLDescrTag(d, off, len1); | |
1657 | ✗ | break; | |
1658 | } | ||
1659 | |||
1660 | |||
1661 | ✗ | done: | |
1662 | ✗ | d->level--; | |
1663 | ✗ | avio_seek(pb, off + len1, SEEK_SET); | |
1664 | ✗ | return ret; | |
1665 | } | ||
1666 | |||
1667 | ✗ | static int mp4_read_iods(AVFormatContext *s, const uint8_t *buf, unsigned size, | |
1668 | Mp4Descr *descr, int *descr_count, int max_descr_count) | ||
1669 | { | ||
1670 | MP4DescrParseContext d; | ||
1671 | int ret; | ||
1672 | |||
1673 | ✗ | ret = init_MP4DescrParseContext(&d, s, buf, size, descr, max_descr_count); | |
1674 | ✗ | if (ret < 0) | |
1675 | ✗ | return ret; | |
1676 | |||
1677 | ✗ | ret = parse_mp4_descr(&d, avio_tell(&d.pb.pub), size, MP4IODescrTag); | |
1678 | |||
1679 | ✗ | *descr_count = d.descr_count; | |
1680 | ✗ | return ret; | |
1681 | } | ||
1682 | |||
1683 | ✗ | static int mp4_read_od(AVFormatContext *s, const uint8_t *buf, unsigned size, | |
1684 | Mp4Descr *descr, int *descr_count, int max_descr_count) | ||
1685 | { | ||
1686 | MP4DescrParseContext d; | ||
1687 | int ret; | ||
1688 | |||
1689 | ✗ | ret = init_MP4DescrParseContext(&d, s, buf, size, descr, max_descr_count); | |
1690 | ✗ | if (ret < 0) | |
1691 | ✗ | return ret; | |
1692 | |||
1693 | ✗ | ret = parse_mp4_descr_arr(&d, avio_tell(&d.pb.pub), size); | |
1694 | |||
1695 | ✗ | *descr_count = d.descr_count; | |
1696 | ✗ | return ret; | |
1697 | } | ||
1698 | |||
1699 | ✗ | static void m4sl_cb(MpegTSFilter *filter, const uint8_t *section, | |
1700 | int section_len) | ||
1701 | { | ||
1702 | ✗ | MpegTSContext *ts = filter->u.section_filter.opaque; | |
1703 | ✗ | MpegTSSectionFilter *tssf = &filter->u.section_filter; | |
1704 | SectionHeader h; | ||
1705 | const uint8_t *p, *p_end; | ||
1706 | ✗ | int mp4_descr_count = 0; | |
1707 | ✗ | Mp4Descr mp4_descr[MAX_MP4_DESCR_COUNT] = { { 0 } }; | |
1708 | int i, pid; | ||
1709 | ✗ | AVFormatContext *s = ts->stream; | |
1710 | |||
1711 | ✗ | p_end = section + section_len - 4; | |
1712 | ✗ | p = section; | |
1713 | ✗ | if (parse_section_header(&h, &p, p_end) < 0) | |
1714 | ✗ | return; | |
1715 | ✗ | if (h.tid != M4OD_TID) | |
1716 | ✗ | return; | |
1717 | ✗ | if (skip_identical(&h, tssf)) | |
1718 | ✗ | return; | |
1719 | |||
1720 | ✗ | mp4_read_od(s, p, (unsigned) (p_end - p), mp4_descr, &mp4_descr_count, | |
1721 | MAX_MP4_DESCR_COUNT); | ||
1722 | |||
1723 | ✗ | for (pid = 0; pid < NB_PID_MAX; pid++) { | |
1724 | ✗ | if (!ts->pids[pid]) | |
1725 | ✗ | continue; | |
1726 | ✗ | for (i = 0; i < mp4_descr_count; i++) { | |
1727 | PESContext *pes; | ||
1728 | AVStream *st; | ||
1729 | FFStream *sti; | ||
1730 | FFIOContext pb; | ||
1731 | ✗ | if (ts->pids[pid]->es_id != mp4_descr[i].es_id) | |
1732 | ✗ | continue; | |
1733 | ✗ | if (ts->pids[pid]->type != MPEGTS_PES) { | |
1734 | ✗ | av_log(s, AV_LOG_ERROR, "pid %x is not PES\n", pid); | |
1735 | ✗ | continue; | |
1736 | } | ||
1737 | ✗ | pes = ts->pids[pid]->u.pes_filter.opaque; | |
1738 | ✗ | st = pes->st; | |
1739 | ✗ | if (!st) | |
1740 | ✗ | continue; | |
1741 | ✗ | sti = ffstream(st); | |
1742 | |||
1743 | ✗ | pes->sl = mp4_descr[i].sl; | |
1744 | |||
1745 | ✗ | ffio_init_read_context(&pb, mp4_descr[i].dec_config_descr, | |
1746 | mp4_descr[i].dec_config_descr_len); | ||
1747 | ✗ | ff_mp4_read_dec_config_descr(s, st, &pb.pub); | |
1748 | ✗ | if (st->codecpar->codec_id == AV_CODEC_ID_AAC && | |
1749 | ✗ | st->codecpar->extradata_size > 0) | |
1750 | ✗ | sti->need_parsing = 0; | |
1751 | ✗ | if (st->codecpar->codec_id == AV_CODEC_ID_H264 && | |
1752 | ✗ | st->codecpar->extradata_size > 0) | |
1753 | ✗ | sti->need_parsing = 0; | |
1754 | |||
1755 | ✗ | st->codecpar->codec_type = avcodec_get_type(st->codecpar->codec_id); | |
1756 | ✗ | sti->need_context_update = 1; | |
1757 | } | ||
1758 | } | ||
1759 | ✗ | for (i = 0; i < mp4_descr_count; i++) | |
1760 | ✗ | av_free(mp4_descr[i].dec_config_descr); | |
1761 | } | ||
1762 | |||
1763 | ✗ | static void scte_data_cb(MpegTSFilter *filter, const uint8_t *section, | |
1764 | int section_len) | ||
1765 | { | ||
1766 | ✗ | AVProgram *prg = NULL; | |
1767 | ✗ | MpegTSContext *ts = filter->u.section_filter.opaque; | |
1768 | |||
1769 | ✗ | int idx = ff_find_stream_index(ts->stream, filter->pid); | |
1770 | ✗ | if (idx < 0) | |
1771 | ✗ | return; | |
1772 | |||
1773 | /** | ||
1774 | * In case we receive an SCTE-35 packet before mpegts context is fully | ||
1775 | * initialized. | ||
1776 | */ | ||
1777 | ✗ | if (!ts->pkt) | |
1778 | ✗ | return; | |
1779 | |||
1780 | ✗ | new_data_packet(section, section_len, ts->pkt); | |
1781 | ✗ | ts->pkt->stream_index = idx; | |
1782 | ✗ | prg = av_find_program_from_stream(ts->stream, NULL, idx); | |
1783 | ✗ | if (prg && prg->pcr_pid != -1 && prg->discard != AVDISCARD_ALL) { | |
1784 | ✗ | MpegTSFilter *f = ts->pids[prg->pcr_pid]; | |
1785 | ✗ | if (f && f->last_pcr != -1) | |
1786 | ✗ | ts->pkt->pts = ts->pkt->dts = f->last_pcr/300; | |
1787 | } | ||
1788 | ✗ | ts->stop_parse = 1; | |
1789 | |||
1790 | } | ||
1791 | |||
1792 | static const uint8_t opus_coupled_stream_cnt[9] = { | ||
1793 | 1, 0, 1, 1, 2, 2, 2, 3, 3 | ||
1794 | }; | ||
1795 | |||
1796 | static const uint8_t opus_stream_cnt[9] = { | ||
1797 | 1, 1, 1, 2, 2, 3, 4, 4, 5, | ||
1798 | }; | ||
1799 | |||
1800 | static const uint8_t opus_channel_map[8][8] = { | ||
1801 | { 0 }, | ||
1802 | { 0,1 }, | ||
1803 | { 0,2,1 }, | ||
1804 | { 0,1,2,3 }, | ||
1805 | { 0,4,1,2,3 }, | ||
1806 | { 0,4,1,2,3,5 }, | ||
1807 | { 0,4,1,2,3,5,6 }, | ||
1808 | { 0,6,1,2,3,4,5,7 }, | ||
1809 | }; | ||
1810 | |||
1811 | 845 | int ff_parse_mpeg2_descriptor(AVFormatContext *fc, AVStream *st, int stream_type, | |
1812 | const uint8_t **pp, const uint8_t *desc_list_end, | ||
1813 | Mp4Descr *mp4_descr, int mp4_descr_count, int pid, | ||
1814 | MpegTSContext *ts) | ||
1815 | { | ||
1816 | 845 | FFStream *const sti = ffstream(st); | |
1817 | const uint8_t *desc_end; | ||
1818 | int desc_len, desc_tag, desc_es_id, ext_desc_tag, channels, channel_config_code; | ||
1819 | char language[252]; | ||
1820 | int i; | ||
1821 | |||
1822 | 845 | desc_tag = get8(pp, desc_list_end); | |
1823 |
2/2✓ Branch 0 taken 519 times.
✓ Branch 1 taken 326 times.
|
845 | if (desc_tag < 0) |
1824 | 519 | return AVERROR_INVALIDDATA; | |
1825 | 326 | desc_len = get8(pp, desc_list_end); | |
1826 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 326 times.
|
326 | if (desc_len < 0) |
1827 | ✗ | return AVERROR_INVALIDDATA; | |
1828 | 326 | desc_end = *pp + desc_len; | |
1829 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 326 times.
|
326 | if (desc_end > desc_list_end) |
1830 | ✗ | return AVERROR_INVALIDDATA; | |
1831 | |||
1832 | 326 | av_log(fc, AV_LOG_TRACE, "tag: 0x%02x len=%d\n", desc_tag, desc_len); | |
1833 | |||
1834 |
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) && |
1835 | stream_type == STREAM_TYPE_PRIVATE_DATA) | ||
1836 | 12 | mpegts_find_stream_type(st, desc_tag, DESC_types); | |
1837 | |||
1838 |
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) { |
1839 | ✗ | case VIDEO_STREAM_DESCRIPTOR: | |
1840 | ✗ | if (get8(pp, desc_end) & 0x1) { | |
1841 | ✗ | st->disposition |= AV_DISPOSITION_STILL_IMAGE; | |
1842 | } | ||
1843 | ✗ | break; | |
1844 | ✗ | case SL_DESCRIPTOR: | |
1845 | ✗ | desc_es_id = get16(pp, desc_end); | |
1846 | ✗ | if (desc_es_id < 0) | |
1847 | ✗ | break; | |
1848 | ✗ | if (ts && ts->pids[pid]) | |
1849 | ✗ | ts->pids[pid]->es_id = desc_es_id; | |
1850 | ✗ | for (i = 0; i < mp4_descr_count; i++) | |
1851 | ✗ | if (mp4_descr[i].dec_config_descr_len && | |
1852 | ✗ | mp4_descr[i].es_id == desc_es_id) { | |
1853 | FFIOContext pb; | ||
1854 | ✗ | ffio_init_read_context(&pb, mp4_descr[i].dec_config_descr, | |
1855 | ✗ | mp4_descr[i].dec_config_descr_len); | |
1856 | ✗ | ff_mp4_read_dec_config_descr(fc, st, &pb.pub); | |
1857 | ✗ | if (st->codecpar->codec_id == AV_CODEC_ID_AAC && | |
1858 | ✗ | st->codecpar->extradata_size > 0) { | |
1859 | ✗ | sti->need_parsing = 0; | |
1860 | ✗ | sti->need_context_update = 1; | |
1861 | } | ||
1862 | ✗ | if (st->codecpar->codec_id == AV_CODEC_ID_MPEG4SYSTEMS) | |
1863 | ✗ | mpegts_open_section_filter(ts, pid, m4sl_cb, ts, 1); | |
1864 | } | ||
1865 | ✗ | break; | |
1866 | ✗ | case FMC_DESCRIPTOR: | |
1867 | ✗ | if (get16(pp, desc_end) < 0) | |
1868 | ✗ | break; | |
1869 | ✗ | if (mp4_descr_count > 0 && | |
1870 | ✗ | (st->codecpar->codec_id == AV_CODEC_ID_AAC_LATM || | |
1871 | ✗ | (sti->request_probe == 0 && st->codecpar->codec_id == AV_CODEC_ID_NONE) || | |
1872 | ✗ | sti->request_probe > 0) && | |
1873 | ✗ | mp4_descr->dec_config_descr_len && mp4_descr->es_id == pid) { | |
1874 | FFIOContext pb; | ||
1875 | ✗ | ffio_init_read_context(&pb, mp4_descr->dec_config_descr, | |
1876 | mp4_descr->dec_config_descr_len); | ||
1877 | ✗ | ff_mp4_read_dec_config_descr(fc, st, &pb.pub); | |
1878 | ✗ | if (st->codecpar->codec_id == AV_CODEC_ID_AAC && | |
1879 | ✗ | st->codecpar->extradata_size > 0) { | |
1880 | ✗ | sti->request_probe = sti->need_parsing = 0; | |
1881 | ✗ | st->codecpar->codec_type = AVMEDIA_TYPE_AUDIO; | |
1882 | ✗ | sti->need_context_update = 1; | |
1883 | } | ||
1884 | } | ||
1885 | ✗ | break; | |
1886 | ✗ | case 0x56: /* DVB teletext descriptor */ | |
1887 | { | ||
1888 | ✗ | uint8_t *extradata = NULL; | |
1889 | ✗ | int language_count = desc_len / 5, ret; | |
1890 | |||
1891 | ✗ | if (desc_len > 0 && desc_len % 5 != 0) | |
1892 | ✗ | return AVERROR_INVALIDDATA; | |
1893 | |||
1894 | ✗ | if (language_count > 0) { | |
1895 | /* 4 bytes per language code (3 bytes) with comma or NUL byte should fit language buffer */ | ||
1896 | ✗ | av_assert0(language_count <= sizeof(language) / 4); | |
1897 | |||
1898 | ✗ | if (st->codecpar->extradata == NULL) { | |
1899 | ✗ | ret = ff_alloc_extradata(st->codecpar, language_count * 2); | |
1900 | ✗ | if (ret < 0) | |
1901 | ✗ | return ret; | |
1902 | } | ||
1903 | |||
1904 | ✗ | if (st->codecpar->extradata_size < language_count * 2) | |
1905 | ✗ | return AVERROR_INVALIDDATA; | |
1906 | |||
1907 | ✗ | extradata = st->codecpar->extradata; | |
1908 | |||
1909 | ✗ | for (i = 0; i < language_count; i++) { | |
1910 | ✗ | language[i * 4 + 0] = get8(pp, desc_end); | |
1911 | ✗ | language[i * 4 + 1] = get8(pp, desc_end); | |
1912 | ✗ | language[i * 4 + 2] = get8(pp, desc_end); | |
1913 | ✗ | language[i * 4 + 3] = ','; | |
1914 | |||
1915 | ✗ | memcpy(extradata, *pp, 2); | |
1916 | ✗ | extradata += 2; | |
1917 | |||
1918 | ✗ | *pp += 2; | |
1919 | } | ||
1920 | |||
1921 | ✗ | language[i * 4 - 1] = 0; | |
1922 | ✗ | av_dict_set(&st->metadata, "language", language, 0); | |
1923 | ✗ | sti->need_context_update = 1; | |
1924 | } | ||
1925 | } | ||
1926 | ✗ | break; | |
1927 | 9 | case 0x59: /* subtitling descriptor */ | |
1928 | { | ||
1929 | /* 8 bytes per DVB subtitle substream data: | ||
1930 | * ISO_639_language_code (3 bytes), | ||
1931 | * subtitling_type (1 byte), | ||
1932 | * composition_page_id (2 bytes), | ||
1933 | * ancillary_page_id (2 bytes) */ | ||
1934 | 9 | int language_count = desc_len / 8, ret; | |
1935 | |||
1936 |
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) |
1937 | ✗ | return AVERROR_INVALIDDATA; | |
1938 | |||
1939 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 9 times.
|
9 | if (language_count > 1) { |
1940 | ✗ | avpriv_request_sample(fc, "DVB subtitles with multiple languages"); | |
1941 | } | ||
1942 | |||
1943 |
1/2✓ Branch 0 taken 9 times.
✗ Branch 1 not taken.
|
9 | if (language_count > 0) { |
1944 | uint8_t *extradata; | ||
1945 | |||
1946 | /* 4 bytes per language code (3 bytes) with comma or NUL byte should fit language buffer */ | ||
1947 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 9 times.
|
9 | av_assert0(language_count <= sizeof(language) / 4); |
1948 | |||
1949 |
2/2✓ Branch 0 taken 3 times.
✓ Branch 1 taken 6 times.
|
9 | if (st->codecpar->extradata == NULL) { |
1950 | 3 | ret = ff_alloc_extradata(st->codecpar, language_count * 5); | |
1951 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 3 times.
|
3 | if (ret < 0) |
1952 | ✗ | return ret; | |
1953 | } | ||
1954 | |||
1955 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 9 times.
|
9 | if (st->codecpar->extradata_size < language_count * 5) |
1956 | ✗ | return AVERROR_INVALIDDATA; | |
1957 | |||
1958 | 9 | extradata = st->codecpar->extradata; | |
1959 | |||
1960 |
2/2✓ Branch 0 taken 9 times.
✓ Branch 1 taken 9 times.
|
18 | for (i = 0; i < language_count; i++) { |
1961 | 9 | language[i * 4 + 0] = get8(pp, desc_end); | |
1962 | 9 | language[i * 4 + 1] = get8(pp, desc_end); | |
1963 | 9 | language[i * 4 + 2] = get8(pp, desc_end); | |
1964 | 9 | language[i * 4 + 3] = ','; | |
1965 | |||
1966 | /* hearing impaired subtitles detection using subtitling_type */ | ||
1967 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 9 times.
|
9 | switch (*pp[0]) { |
1968 | ✗ | case 0x20: /* DVB subtitles (for the hard of hearing) with no monitor aspect ratio criticality */ | |
1969 | case 0x21: /* DVB subtitles (for the hard of hearing) for display on 4:3 aspect ratio monitor */ | ||
1970 | case 0x22: /* DVB subtitles (for the hard of hearing) for display on 16:9 aspect ratio monitor */ | ||
1971 | case 0x23: /* DVB subtitles (for the hard of hearing) for display on 2.21:1 aspect ratio monitor */ | ||
1972 | case 0x24: /* DVB subtitles (for the hard of hearing) for display on a high definition monitor */ | ||
1973 | case 0x25: /* DVB subtitles (for the hard of hearing) with plano-stereoscopic disparity for display on a high definition monitor */ | ||
1974 | ✗ | st->disposition |= AV_DISPOSITION_HEARING_IMPAIRED; | |
1975 | ✗ | break; | |
1976 | } | ||
1977 | |||
1978 | 9 | extradata[4] = get8(pp, desc_end); /* subtitling_type */ | |
1979 | 9 | memcpy(extradata, *pp, 4); /* composition_page_id and ancillary_page_id */ | |
1980 | 9 | extradata += 5; | |
1981 | |||
1982 | 9 | *pp += 4; | |
1983 | } | ||
1984 | |||
1985 | 9 | language[i * 4 - 1] = 0; | |
1986 | 9 | av_dict_set(&st->metadata, "language", language, 0); | |
1987 | 9 | sti->need_context_update = 1; | |
1988 | } | ||
1989 | } | ||
1990 | 9 | break; | |
1991 | 204 | case ISO_639_LANGUAGE_DESCRIPTOR: | |
1992 |
2/2✓ Branch 0 taken 198 times.
✓ Branch 1 taken 204 times.
|
402 | for (i = 0; i + 4 <= desc_len; i += 4) { |
1993 | 198 | language[i + 0] = get8(pp, desc_end); | |
1994 | 198 | language[i + 1] = get8(pp, desc_end); | |
1995 | 198 | language[i + 2] = get8(pp, desc_end); | |
1996 | 198 | language[i + 3] = ','; | |
1997 | 198 | switch (get8(pp, desc_end)) { | |
1998 | ✗ | case 0x01: | |
1999 | ✗ | st->disposition |= AV_DISPOSITION_CLEAN_EFFECTS; | |
2000 | ✗ | break; | |
2001 | ✗ | case 0x02: | |
2002 | ✗ | st->disposition |= AV_DISPOSITION_HEARING_IMPAIRED; | |
2003 | ✗ | break; | |
2004 | 44 | case 0x03: | |
2005 | 44 | st->disposition |= AV_DISPOSITION_VISUAL_IMPAIRED; | |
2006 | 44 | st->disposition |= AV_DISPOSITION_DESCRIPTIONS; | |
2007 | 44 | break; | |
2008 | } | ||
2009 | } | ||
2010 |
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]) { |
2011 | 194 | language[i - 1] = 0; | |
2012 | /* don't overwrite language, as it may already have been set by | ||
2013 | * another, more specific descriptor (e.g. supplementary audio) */ | ||
2014 | 194 | av_dict_set(&st->metadata, "language", language, AV_DICT_DONT_OVERWRITE); | |
2015 | } | ||
2016 | 204 | break; | |
2017 | 8 | case REGISTRATION_DESCRIPTOR: | |
2018 | 8 | st->codecpar->codec_tag = bytestream_get_le32(pp); | |
2019 | 8 | av_log(fc, AV_LOG_TRACE, "reg_desc=%.4s\n", (char *)&st->codecpar->codec_tag); | |
2020 |
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) { |
2021 | 3 | mpegts_find_stream_type(st, st->codecpar->codec_tag, REGD_types); | |
2022 |
2/2✓ Branch 0 taken 2 times.
✓ Branch 1 taken 1 times.
|
3 | if (st->codecpar->codec_tag == MKTAG('B', 'S', 'S', 'D')) |
2023 | 2 | sti->request_probe = 50; | |
2024 | } | ||
2025 | 8 | break; | |
2026 | 31 | case 0x52: /* stream identifier descriptor */ | |
2027 | 31 | sti->stream_identifier = 1 + get8(pp, desc_end); | |
2028 | 31 | break; | |
2029 | 4 | case METADATA_DESCRIPTOR: | |
2030 |
1/2✓ Branch 1 taken 4 times.
✗ Branch 2 not taken.
|
4 | if (get16(pp, desc_end) == 0xFFFF) |
2031 | 4 | *pp += 4; | |
2032 |
1/2✓ Branch 1 taken 4 times.
✗ Branch 2 not taken.
|
4 | if (get8(pp, desc_end) == 0xFF) { |
2033 | 4 | st->codecpar->codec_tag = bytestream_get_le32(pp); | |
2034 |
2/2✓ Branch 0 taken 1 times.
✓ Branch 1 taken 3 times.
|
4 | if (st->codecpar->codec_id == AV_CODEC_ID_NONE) |
2035 | 1 | mpegts_find_stream_type(st, st->codecpar->codec_tag, METADATA_types); | |
2036 | } | ||
2037 | 4 | break; | |
2038 | 4 | case 0x7f: /* DVB extension descriptor */ | |
2039 | 4 | ext_desc_tag = get8(pp, desc_end); | |
2040 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 4 times.
|
4 | if (ext_desc_tag < 0) |
2041 | ✗ | return AVERROR_INVALIDDATA; | |
2042 |
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 && |
2043 | ext_desc_tag == 0x80) { /* User defined (provisional Opus) */ | ||
2044 |
2/2✓ Branch 0 taken 1 times.
✓ Branch 1 taken 2 times.
|
3 | if (!st->codecpar->extradata) { |
2045 | 1 | st->codecpar->extradata = av_mallocz(sizeof(opus_default_extradata) + | |
2046 | AV_INPUT_BUFFER_PADDING_SIZE); | ||
2047 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 1 times.
|
1 | if (!st->codecpar->extradata) |
2048 | ✗ | return AVERROR(ENOMEM); | |
2049 | |||
2050 | 1 | st->codecpar->extradata_size = sizeof(opus_default_extradata); | |
2051 | 1 | memcpy(st->codecpar->extradata, opus_default_extradata, sizeof(opus_default_extradata)); | |
2052 | |||
2053 | 1 | channel_config_code = get8(pp, desc_end); | |
2054 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 1 times.
|
1 | if (channel_config_code < 0) |
2055 | ✗ | return AVERROR_INVALIDDATA; | |
2056 |
1/2✓ Branch 0 taken 1 times.
✗ Branch 1 not taken.
|
1 | if (channel_config_code <= 0x8) { |
2057 |
1/2✓ Branch 0 taken 1 times.
✗ Branch 1 not taken.
|
1 | st->codecpar->extradata[9] = channels = channel_config_code ? channel_config_code : 2; |
2058 | 1 | AV_WL32(&st->codecpar->extradata[12], 48000); | |
2059 |
1/2✓ Branch 0 taken 1 times.
✗ Branch 1 not taken.
|
1 | st->codecpar->extradata[18] = channel_config_code ? (channels > 2) : /* Dual Mono */ 255; |
2060 | 1 | st->codecpar->extradata[19] = opus_stream_cnt[channel_config_code]; | |
2061 | 1 | st->codecpar->extradata[20] = opus_coupled_stream_cnt[channel_config_code]; | |
2062 | 1 | memcpy(&st->codecpar->extradata[21], opus_channel_map[channels - 1], channels); | |
2063 |
1/2✓ Branch 0 taken 1 times.
✗ Branch 1 not taken.
|
1 | st->codecpar->extradata_size = st->codecpar->extradata[18] ? 21 + channels : 19; |
2064 | } else { | ||
2065 | ✗ | avpriv_request_sample(fc, "Opus in MPEG-TS - channel_config_code > 0x8"); | |
2066 | } | ||
2067 | 1 | sti->need_parsing = AVSTREAM_PARSE_FULL; | |
2068 | 1 | sti->need_context_update = 1; | |
2069 | } | ||
2070 | } | ||
2071 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 4 times.
|
4 | if (ext_desc_tag == 0x06) { /* supplementary audio descriptor */ |
2072 | int flags; | ||
2073 | |||
2074 | ✗ | if (desc_len < 1) | |
2075 | ✗ | return AVERROR_INVALIDDATA; | |
2076 | ✗ | flags = get8(pp, desc_end); | |
2077 | |||
2078 | ✗ | if ((flags & 0x80) == 0) /* mix_type */ | |
2079 | ✗ | st->disposition |= AV_DISPOSITION_DEPENDENT; | |
2080 | |||
2081 | ✗ | switch ((flags >> 2) & 0x1F) { /* editorial_classification */ | |
2082 | ✗ | case 0x01: | |
2083 | ✗ | st->disposition |= AV_DISPOSITION_VISUAL_IMPAIRED; | |
2084 | ✗ | st->disposition |= AV_DISPOSITION_DESCRIPTIONS; | |
2085 | ✗ | break; | |
2086 | ✗ | case 0x02: | |
2087 | ✗ | st->disposition |= AV_DISPOSITION_HEARING_IMPAIRED; | |
2088 | ✗ | break; | |
2089 | ✗ | case 0x03: | |
2090 | ✗ | st->disposition |= AV_DISPOSITION_VISUAL_IMPAIRED; | |
2091 | ✗ | break; | |
2092 | } | ||
2093 | |||
2094 | ✗ | if (flags & 0x01) { /* language_code_present */ | |
2095 | ✗ | if (desc_len < 4) | |
2096 | ✗ | return AVERROR_INVALIDDATA; | |
2097 | ✗ | language[0] = get8(pp, desc_end); | |
2098 | ✗ | language[1] = get8(pp, desc_end); | |
2099 | ✗ | language[2] = get8(pp, desc_end); | |
2100 | ✗ | language[3] = 0; | |
2101 | |||
2102 | /* This language always has to override a possible | ||
2103 | * ISO 639 language descriptor language */ | ||
2104 | ✗ | if (language[0]) | |
2105 | ✗ | av_dict_set(&st->metadata, "language", language, 0); | |
2106 | } | ||
2107 | } | ||
2108 | 4 | break; | |
2109 | 6 | case 0x6a: /* ac-3_descriptor */ | |
2110 | { | ||
2111 | 6 | int component_type_flag = get8(pp, desc_end) & (1 << 7); | |
2112 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 6 times.
|
6 | if (component_type_flag) { |
2113 | ✗ | int component_type = get8(pp, desc_end); | |
2114 | ✗ | int service_type_mask = 0x38; // 0b00111000 | |
2115 | ✗ | int service_type = ((component_type & service_type_mask) >> 3); | |
2116 | ✗ | if (service_type == 0x02 /* 0b010 */) { | |
2117 | ✗ | st->disposition |= AV_DISPOSITION_DESCRIPTIONS; | |
2118 | ✗ | av_log(ts ? ts->stream : fc, AV_LOG_DEBUG, "New track disposition for id %u: %u\n", st->id, st->disposition); | |
2119 | } | ||
2120 | } | ||
2121 | } | ||
2122 | 6 | break; | |
2123 | ✗ | case 0x7a: /* enhanced_ac-3_descriptor */ | |
2124 | { | ||
2125 | ✗ | int component_type_flag = get8(pp, desc_end) & (1 << 7); | |
2126 | ✗ | if (component_type_flag) { | |
2127 | ✗ | int component_type = get8(pp, desc_end); | |
2128 | ✗ | int service_type_mask = 0x38; // 0b00111000 | |
2129 | ✗ | int service_type = ((component_type & service_type_mask) >> 3); | |
2130 | ✗ | if (service_type == 0x02 /* 0b010 */) { | |
2131 | ✗ | st->disposition |= AV_DISPOSITION_DESCRIPTIONS; | |
2132 | ✗ | av_log(ts ? ts->stream : fc, AV_LOG_DEBUG, "New track disposition for id %u: %u\n", st->id, st->disposition); | |
2133 | } | ||
2134 | } | ||
2135 | } | ||
2136 | ✗ | break; | |
2137 | ✗ | case 0xfd: /* ARIB data coding type descriptor */ | |
2138 | // STD-B24, fascicle 3, chapter 4 defines private_stream_1 | ||
2139 | // for captions | ||
2140 | ✗ | if (stream_type == STREAM_TYPE_PRIVATE_DATA) { | |
2141 | // This structure is defined in STD-B10, part 1, listing 5.4 and | ||
2142 | // part 2, 6.2.20). | ||
2143 | // Listing of data_component_ids is in STD-B10, part 2, Annex J. | ||
2144 | // Component tag limits are documented in TR-B14, fascicle 2, | ||
2145 | // Vol. 3, Section 2, 4.2.8.1 | ||
2146 | ✗ | int actual_component_tag = sti->stream_identifier - 1; | |
2147 | ✗ | int picked_profile = AV_PROFILE_UNKNOWN; | |
2148 | ✗ | int data_component_id = get16(pp, desc_end); | |
2149 | ✗ | if (data_component_id < 0) | |
2150 | ✗ | return AVERROR_INVALIDDATA; | |
2151 | |||
2152 | switch (data_component_id) { | ||
2153 | ✗ | case 0x0008: | |
2154 | // [0x30..0x37] are component tags utilized for | ||
2155 | // non-mobile captioning service ("profile A"). | ||
2156 | ✗ | if (actual |