FFmpeg: libavformat/mpegts.c Source File

FFmpeg

[フレーム]

libavformat

mpegts.c

Go to the documentation of this file.

1 /*

2 * MPEG2 transport stream (aka DVB) demuxer

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 */

22 #include "libavutil/buffer.h"

23 #include "libavutil/crc.h"

24 #include "libavutil/intreadwrite.h"

25 #include "libavutil/log.h"

26 #include "libavutil/dict.h"

27 #include "libavutil/mathematics.h"

28 #include "libavutil/opt.h"

29 #include "libavutil/avassert.h"

30 #include "libavcodec/bytestream.h"

31 #include "libavcodec/get_bits.h"

32 #include "avformat.h"

33 #include "mpegts.h"

34 #include "internal.h"

35 #include "avio_internal.h"

36 #include "seek.h"

37 #include "mpeg.h"

38 #include "isom.h"

40 /* maximum size in which we look for synchronisation if

41 * synchronisation is lost */

42 #define MAX_RESYNC_SIZE 65536

44 #define MAX_PES_PAYLOAD 200 * 1024

46 #define MAX_MP4_DESCR_COUNT 16

48 #define MOD_UNLIKELY(modulus, dividend, divisor, prev_dividend) \

49 do { \

50 if ((prev_dividend) == 0 || (dividend) - (prev_dividend) != (divisor)) \

51 (modulus) = (dividend) % (divisor); \

52 (prev_dividend) = (dividend); \

53 } while (0)

55 enum MpegTSFilterType {

56 MPEGTS_PES,

57 MPEGTS_SECTION,

58 MPEGTS_PCR,

59 };

61 typedef struct MpegTSFilter MpegTSFilter;

63 typedef int PESCallback (MpegTSFilter *f, const uint8_t *buf, int len,

64 int is_start, int64_t pos);

66 typedef struct MpegTSPESFilter {

67 PESCallback *pes_cb;

68 void *opaque;

69 } MpegTSPESFilter;

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

73 typedef void SetServiceCallback (void *opaque, int ret);

75 typedef struct MpegTSSectionFilter {

76 int section_index;

77 int section_h_size;

78 uint8_t *section_buf;

79 unsigned int check_crc : 1;

80 unsigned int end_of_section_reached : 1;

81 SectionCallback *section_cb;

82 void *opaque;

83 } MpegTSSectionFilter;

85 struct MpegTSFilter {

86 int pid;

87 int es_id;

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

89 int64_t last_pcr;

90 enum MpegTSFilterType type;

91 union {

92 MpegTSPESFilter pes_filter;

93 MpegTSSectionFilter section_filter;

94 } u;

95 };

97 #define MAX_PIDS_PER_PROGRAM 64

98 struct Program {

99 unsigned int id; // program id/service id

100 unsigned int nb_pids;

101 unsigned int pids[MAX_PIDS_PER_PROGRAM];

102

103 /** have we found pmt for this program */

104 int pmt_found;

105 };

106

107 struct MpegTSContext {

108 const AVClass *class;

109 /* user data */

110 AVFormatContext *stream;

111 /** raw packet size, including FEC if present */

112 int raw_packet_size;

113

114 int size_stat[3];

115 int size_stat_count;

116 #define SIZE_STAT_THRESHOLD 10

117

118 int64_t pos47_full;

119

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

121 int auto_guess;

122

123 /** compute exact PCR for each transport stream packet */

124 int mpeg2ts_compute_pcr;

125

126 /** fix dvb teletext pts */

127 int fix_teletext_pts;

128

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

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

131

132 /* data needed to handle file based ts */

133 /** stop parsing loop */

134 int stop_parse;

135 /** packet containing Audio/Video data */

136 AVPacket *pkt;

137 /** to detect seek */

138 int64_t last_pos;

139

140 int skip_changes;

141 int skip_clear;

142

143 /******************************************/

144 /* private mpegts data */

145 /* scan context */

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

147 unsigned int nb_prg;

148 struct Program *prg;

149

150 int8_t crc_validity[NB_PID_MAX];

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

152 MpegTSFilter *pids[NB_PID_MAX];

153 int current_pid;

154 };

155

156 static const AVOption mpegtsraw_options[] = {

157 { "compute_pcr", "Compute exact PCR for each transport stream packet.",

158 offsetof(MpegTSContext, mpeg2ts_compute_pcr), AV_OPT_TYPE_INT,

159 { .i64 = 0 }, 0, 1, AV_OPT_FLAG_DECODING_PARAM },

160 { "ts_packetsize", "Output option carrying the raw packet size.",

161 offsetof(MpegTSContext, raw_packet_size), AV_OPT_TYPE_INT,

162 { .i64 = 0 }, 0, 0,

163 AV_OPT_FLAG_DECODING_PARAM | AV_OPT_FLAG_EXPORT | AV_OPT_FLAG_READONLY },

164 { NULL },

165 };

166

167 static const AVClass mpegtsraw_class = {

168 .class_name = "mpegtsraw demuxer",

169 .item_name = av_default_item_name,

170 .option = mpegtsraw_options,

171 .version = LIBAVUTIL_VERSION_INT,

172 };

173

174 static const AVOption mpegts_options[] = {

175 {"fix_teletext_pts", "Try to fix pts values of dvb teletext streams.", offsetof(MpegTSContext, fix_teletext_pts), AV_OPT_TYPE_INT,

176 {.i64 = 1}, 0, 1, AV_OPT_FLAG_DECODING_PARAM },

177 {"ts_packetsize", "Output option carrying the raw packet size.", offsetof(MpegTSContext, raw_packet_size), AV_OPT_TYPE_INT,

178 {.i64 = 0}, 0, 0, AV_OPT_FLAG_DECODING_PARAM | AV_OPT_FLAG_EXPORT | AV_OPT_FLAG_READONLY },

179 {"skip_changes", "Skip changing / adding streams / programs.", offsetof(MpegTSContext, skip_changes), AV_OPT_TYPE_INT,

180 {.i64 = 0}, 0, 1, 0 },

181 {"skip_clear", "Skip clearing programs.", offsetof(MpegTSContext, skip_clear), AV_OPT_TYPE_INT,

182 {.i64 = 0}, 0, 1, 0 },

183 { NULL },

184 };

185

186 static const AVClass mpegts_class = {

187 .class_name = "mpegts demuxer",

188 .item_name = av_default_item_name,

189 .option = mpegts_options,

190 .version = LIBAVUTIL_VERSION_INT,

191 };

192

193 /* TS stream handling */

194

195 enum MpegTSState {

196 MPEGTS_HEADER = 0,

197 MPEGTS_PESHEADER,

198 MPEGTS_PESHEADER_FILL,

199 MPEGTS_PAYLOAD,

200 MPEGTS_SKIP,

201 };

202

203 /* enough for PES header + length */

204 #define PES_START_SIZE 6

205 #define PES_HEADER_SIZE 9

206 #define MAX_PES_HEADER_SIZE (9 + 255)

207

208 typedef struct PESContext {

209 int pid;

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

211 int stream_type;

212 MpegTSContext *ts;

213 AVFormatContext *stream;

214 AVStream *st;

215 AVStream *sub_st; /**< stream for the embedded AC3 stream in HDMV TrueHD */

216 enum MpegTSState state;

217 /* used to get the format */

218 int data_index;

219 int flags; /**< copied to the AVPacket flags */

220 int total_size;

221 int pes_header_size;

222 int extended_stream_id;

223 int64_t pts, dts;

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

225 uint8_t header[MAX_PES_HEADER_SIZE];

226 AVBufferRef *buffer;

227 SLConfigDescr sl;

228 } PESContext;

229

230 extern AVInputFormat ff_mpegts_demuxer;

231

232 static struct Program * get_program(MpegTSContext *ts, unsigned int programid)

233 {

234 int i;

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

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

237 return &ts->prg[i];

238 }

239 }

240 return NULL;

241 }

242

243 static void clear_avprogram(MpegTSContext *ts, unsigned int programid)

244 {

245 AVProgram *prg = NULL;

246 int i;

247

248 for (i = 0; i < ts->stream->nb_programs; i++)

249 if (ts->stream->programs[i]->id == programid) {

250 prg = ts->stream->programs[i];

251 break;

252 }

253 if (!prg)

254 return;

255 prg->nb_stream_indexes = 0;

256 }

257

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

259 {

260 int i;

261

262 clear_avprogram(ts, programid);

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

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

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

266 ts->prg[i].pmt_found = 0;

267 }

268 }

269

270 static void clear_programs(MpegTSContext *ts)

271 {

272 av_freep(&ts->prg);

273 ts->nb_prg = 0;

274 }

275

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

277 {

278 struct Program *p;

279 if (av_reallocp_array(&ts->prg, ts->nb_prg + 1, sizeof(*ts->prg)) < 0) {

280 ts->nb_prg = 0;

281 return;

282 }

283 p = &ts->prg[ts->nb_prg];

284 p->id = programid;

285 p->nb_pids = 0;

286 p->pmt_found = 0;

287 ts->nb_prg++;

288 }

289

290 static void add_pid_to_pmt(MpegTSContext *ts, unsigned int programid,

291 unsigned int pid)

292 {

293 struct Program *p = get_program(ts, programid);

294 if (!p)

295 return;

296

297 if (p->nb_pids >= MAX_PIDS_PER_PROGRAM)

298 return;

299 p->pids[p->nb_pids++] = pid;

300 }

301

302 static void set_pmt_found(MpegTSContext *ts, unsigned int programid)

303 {

304 struct Program *p = get_program(ts, programid);

305 if (!p)

306 return;

307

308 p->pmt_found = 1;

309 }

310

311 static void set_pcr_pid(AVFormatContext *s, unsigned int programid, unsigned int pid)

312 {

313 int i;

314 for (i = 0; i < s->nb_programs; i++) {

315 if (s->programs[i]->id == programid) {

316 s->programs[i]->pcr_pid = pid;

317 break;

318 }

319 }

320 }

321

322 /**

323 * @brief discard_pid() decides if the pid is to be discarded according

324 * to caller's programs selection

325 * @param ts : - TS context

326 * @param pid : - pid

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

328 * 0 otherwise

329 */

330 static int discard_pid(MpegTSContext *ts, unsigned int pid)

331 {

332 int i, j, k;

333 int used = 0, discarded = 0;

334 struct Program *p;

335

336 /* If none of the programs have .discard=AVDISCARD_ALL then there's

337 * no way we have to discard this packet */

338 for (k = 0; k < ts->stream->nb_programs; k++)

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

340 break;

341 if (k == ts->stream->nb_programs)

342 return 0;

343

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

345 p = &ts->prg[i];

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

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

348 continue;

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

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

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

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

353 discarded++;

354 else

355 used++;

356 }

357 }

358 }

359 }

360

361 return !used && discarded;

362 }

363

364 /**

365 * Assemble PES packets out of TS packets, and then call the "section_cb"

366 * function when they are complete.

367 */

368 static void write_section_data(MpegTSContext *ts, MpegTSFilter *tss1,

369 const uint8_t *buf, int buf_size, int is_start)

370 {

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

372 int len;

373

374 if (is_start) {

375 memcpy(tss->section_buf, buf, buf_size);

376 tss->section_index = buf_size;

377 tss->section_h_size = -1;

378 tss->end_of_section_reached = 0;

379 } else {

380 if (tss->end_of_section_reached)

381 return;

382 len = 4096 - tss->section_index;

383 if (buf_size < len)

384 len = buf_size;

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

386 tss->section_index += len;

387 }

388

389 /* compute section length if possible */

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

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

392 if (len > 4096)

393 return;

394 tss->section_h_size = len;

395 }

396

397 if (tss->section_h_size != -1 &&

398 tss->section_index >= tss->section_h_size) {

399 int crc_valid = 1;

400 tss->end_of_section_reached = 1;

401

402 if (tss->check_crc) {

403 crc_valid = !av_crc(av_crc_get_table(AV_CRC_32_IEEE), -1, tss->section_buf, tss->section_h_size);

404 if (crc_valid) {

405 ts->crc_validity[ tss1->pid ] = 100;

406 }else if (ts->crc_validity[ tss1->pid ] > -10) {

407 ts->crc_validity[ tss1->pid ]--;

408 }else

409 crc_valid = 2;

410 }

411 if (crc_valid)

412 tss->section_cb(tss1, tss->section_buf, tss->section_h_size);

413 }

414 }

415

416 static MpegTSFilter *mpegts_open_filter(MpegTSContext *ts, unsigned int pid,

417 enum MpegTSFilterType type)

418 {

419 MpegTSFilter *filter;

420

421 av_dlog(ts->stream, "Filter: pid=0x%x\n", pid);

422

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

424 return NULL;

425 filter = av_mallocz(sizeof(MpegTSFilter));

426 if (!filter)

427 return NULL;

428 ts->pids[pid] = filter;

429

430 filter->type = type;

431 filter->pid = pid;

432 filter->es_id = -1;

433 filter->last_cc = -1;

434 filter->last_pcr= -1;

435

436 return filter;

437 }

438

439 static MpegTSFilter *mpegts_open_section_filter(MpegTSContext *ts,

440 unsigned int pid,

441 SectionCallback *section_cb,

442 void *opaque,

443 int check_crc)

444 {

445 MpegTSFilter *filter;

446 MpegTSSectionFilter *sec;

447

448 if (!(filter = mpegts_open_filter(ts, pid, MPEGTS_SECTION)))

449 return NULL;

450 sec = &filter->u.section_filter;

451 sec->section_cb = section_cb;

452 sec->opaque = opaque;

453 sec->section_buf = av_malloc(MAX_SECTION_SIZE);

454 sec->check_crc = check_crc;

455 if (!sec->section_buf) {

456 av_free(filter);

457 return NULL;

458 }

459 return filter;

460 }

461

462 static MpegTSFilter *mpegts_open_pes_filter(MpegTSContext *ts, unsigned int pid,

463 PESCallback *pes_cb,

464 void *opaque)

465 {

466 MpegTSFilter *filter;

467 MpegTSPESFilter *pes;

468

469 if (!(filter = mpegts_open_filter(ts, pid, MPEGTS_PES)))

470 return NULL;

471

472 pes = &filter->u.pes_filter;

473 pes->pes_cb = pes_cb;

474 pes->opaque = opaque;

475 return filter;

476 }

477

478 static MpegTSFilter *mpegts_open_pcr_filter(MpegTSContext *ts, unsigned int pid)

479 {

480 return mpegts_open_filter(ts, pid, MPEGTS_PCR);

481 }

482

483 static void mpegts_close_filter(MpegTSContext *ts, MpegTSFilter *filter)

484 {

485 int pid;

486

487 pid = filter->pid;

488 if (filter->type == MPEGTS_SECTION)

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

490 else if (filter->type == MPEGTS_PES) {

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

492 av_buffer_unref(&pes->buffer);

493 /* referenced private data will be freed later in

494 * avformat_close_input */

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

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

497 }

498 }

499

500 av_free(filter);

501 ts->pids[pid] = NULL;

502 }

503

504 static int analyze(const uint8_t *buf, int size, int packet_size, int *index)

505 {

506 int stat[TS_MAX_PACKET_SIZE];

507 int i;

508 int best_score = 0;

509

510 memset(stat, 0, packet_size * sizeof(*stat));

511

512 for (i = 0; i < size - 3; i++) {

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

514 int x = i % packet_size;

515 stat[x]++;

516 if (stat[x] > best_score) {

517 best_score = stat[x];

518 if (index)

519 *index = x;

520 }

521 }

522 }

523

524 return best_score;

525 }

526

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

528 static int get_packet_size(const uint8_t *buf, int size)

529 {

530 int score, fec_score, dvhs_score;

531

532 if (size < (TS_FEC_PACKET_SIZE * 5 + 1))

533 return AVERROR_INVALIDDATA;

534

535 score = analyze(buf, size, TS_PACKET_SIZE, NULL);

536 dvhs_score = analyze(buf, size, TS_DVHS_PACKET_SIZE, NULL);

537 fec_score = analyze(buf, size, TS_FEC_PACKET_SIZE, NULL);

538 av_dlog(NULL, "score: %d, dvhs_score: %d, fec_score: %d \n",

539 score, dvhs_score, fec_score);

540

541 if (score > fec_score && score > dvhs_score)

542 return TS_PACKET_SIZE;

543 else if (dvhs_score > score && dvhs_score > fec_score)

544 return TS_DVHS_PACKET_SIZE;

545 else if (score < fec_score && dvhs_score < fec_score)

546 return TS_FEC_PACKET_SIZE;

547 else

548 return AVERROR_INVALIDDATA;

549 }

550

551 typedef struct SectionHeader {

552 uint8_t tid;

553 uint16_t id;

554 uint8_t version;

555 uint8_t sec_num;

556 uint8_t last_sec_num;

557 } SectionHeader;

558

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

560 {

561 const uint8_t *p;

562 int c;

563

564 p = *pp;

565 if (p >= p_end)

566 return AVERROR_INVALIDDATA;

567 c = *p++;

568 *pp = p;

569 return c;

570 }

571

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

573 {

574 const uint8_t *p;

575 int c;

576

577 p = *pp;

578 if ((p + 1) >= p_end)

579 return AVERROR_INVALIDDATA;

580 c = AV_RB16(p);

581 p += 2;

582 *pp = p;

583 return c;

584 }

585

586 /* read and allocate a DVB string preceded by its length */

587 static char *getstr8(const uint8_t **pp, const uint8_t *p_end)

588 {

589 int len;

590 const uint8_t *p;

591 char *str;

592

593 p = *pp;

594 len = get8(&p, p_end);

595 if (len < 0)

596 return NULL;

597 if ((p + len) > p_end)

598 return NULL;

599 str = av_malloc(len + 1);

600 if (!str)

601 return NULL;

602 memcpy(str, p, len);

603 str[len] = '0円';

604 p += len;

605 *pp = p;

606 return str;

607 }

608

609 static int parse_section_header(SectionHeader *h,

610 const uint8_t **pp, const uint8_t *p_end)

611 {

612 int val;

613

614 val = get8(pp, p_end);

615 if (val < 0)

616 return val;

617 h->tid = val;

618 *pp += 2;

619 val = get16(pp, p_end);

620 if (val < 0)

621 return val;

622 h->id = val;

623 val = get8(pp, p_end);

624 if (val < 0)

625 return val;

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

627 val = get8(pp, p_end);

628 if (val < 0)

629 return val;

630 h->sec_num = val;

631 val = get8(pp, p_end);

632 if (val < 0)

633 return val;

634 h->last_sec_num = val;

635 return 0;

636 }

637

638 typedef struct {

639 uint32_t stream_type;

640 enum AVMediaType codec_type;

641 enum AVCodecID codec_id;

642 } StreamType;

643

644 static const StreamType ISO_types[] = {

645 { 0x01, AVMEDIA_TYPE_VIDEO, AV_CODEC_ID_MPEG2VIDEO },

646 { 0x02, AVMEDIA_TYPE_VIDEO, AV_CODEC_ID_MPEG2VIDEO },

647 { 0x03, AVMEDIA_TYPE_AUDIO, AV_CODEC_ID_MP3 },

648 { 0x04, AVMEDIA_TYPE_AUDIO, AV_CODEC_ID_MP3 },

649 { 0x0f, AVMEDIA_TYPE_AUDIO, AV_CODEC_ID_AAC },

650 { 0x10, AVMEDIA_TYPE_VIDEO, AV_CODEC_ID_MPEG4 },

651 /* Makito encoder sets stream type 0x11 for AAC,

652 * so auto-detect LOAS/LATM instead of hardcoding it. */

653 #if !CONFIG_LOAS_DEMUXER

654 { 0x11, AVMEDIA_TYPE_AUDIO, AV_CODEC_ID_AAC_LATM }, /* LATM syntax */

655 #endif

656 { 0x1b, AVMEDIA_TYPE_VIDEO, AV_CODEC_ID_H264 },

657 { 0x24, AVMEDIA_TYPE_VIDEO, AV_CODEC_ID_HEVC },

658 { 0x42, AVMEDIA_TYPE_VIDEO, AV_CODEC_ID_CAVS },

659 { 0xd1, AVMEDIA_TYPE_VIDEO, AV_CODEC_ID_DIRAC },

660 { 0xea, AVMEDIA_TYPE_VIDEO, AV_CODEC_ID_VC1 },

661 { 0 },

662 };

663

664 static const StreamType HDMV_types[] = {

665 { 0x80, AVMEDIA_TYPE_AUDIO, AV_CODEC_ID_PCM_BLURAY },

666 { 0x81, AVMEDIA_TYPE_AUDIO, AV_CODEC_ID_AC3 },

667 { 0x82, AVMEDIA_TYPE_AUDIO, AV_CODEC_ID_DTS },

668 { 0x83, AVMEDIA_TYPE_AUDIO, AV_CODEC_ID_TRUEHD },

669 { 0x84, AVMEDIA_TYPE_AUDIO, AV_CODEC_ID_EAC3 },

670 { 0x85, AVMEDIA_TYPE_AUDIO, AV_CODEC_ID_DTS }, /* DTS HD */

671 { 0x86, AVMEDIA_TYPE_AUDIO, AV_CODEC_ID_DTS }, /* DTS HD MASTER*/

672 { 0xa1, AVMEDIA_TYPE_AUDIO, AV_CODEC_ID_EAC3 }, /* E-AC3 Secondary Audio */

673 { 0xa2, AVMEDIA_TYPE_AUDIO, AV_CODEC_ID_DTS }, /* DTS Express Secondary Audio */

674 { 0x90, AVMEDIA_TYPE_SUBTITLE, AV_CODEC_ID_HDMV_PGS_SUBTITLE },

675 { 0 },

676 };

677

678 /* ATSC ? */

679 static const StreamType MISC_types[] = {

680 { 0x81, AVMEDIA_TYPE_AUDIO, AV_CODEC_ID_AC3 },

681 { 0x8a, AVMEDIA_TYPE_AUDIO, AV_CODEC_ID_DTS },

682 { 0 },

683 };

684

685 static const StreamType REGD_types[] = {

686 { MKTAG('d', 'r', 'a', 'c'), AVMEDIA_TYPE_VIDEO, AV_CODEC_ID_DIRAC },

687 { MKTAG('A', 'C', '-', '3'), AVMEDIA_TYPE_AUDIO, AV_CODEC_ID_AC3 },

688 { MKTAG('B', 'S', 'S', 'D'), AVMEDIA_TYPE_AUDIO, AV_CODEC_ID_S302M },

689 { MKTAG('D', 'T', 'S', '1'), AVMEDIA_TYPE_AUDIO, AV_CODEC_ID_DTS },

690 { MKTAG('D', 'T', 'S', '2'), AVMEDIA_TYPE_AUDIO, AV_CODEC_ID_DTS },

691 { MKTAG('D', 'T', 'S', '3'), AVMEDIA_TYPE_AUDIO, AV_CODEC_ID_DTS },

692 { MKTAG('H', 'E', 'V', 'C'), AVMEDIA_TYPE_VIDEO, AV_CODEC_ID_HEVC },

693 { MKTAG('K', 'L', 'V', 'A'), AVMEDIA_TYPE_DATA, AV_CODEC_ID_SMPTE_KLV },

694 { MKTAG('V', 'C', '-', '1'), AVMEDIA_TYPE_VIDEO, AV_CODEC_ID_VC1 },

695 { 0 },

696 };

697

698 static const StreamType METADATA_types[] = {

699 { MKTAG('K','L','V','A'), AVMEDIA_TYPE_DATA, AV_CODEC_ID_SMPTE_KLV },

700 { MKTAG('I','D','3',' '), AVMEDIA_TYPE_DATA, AV_CODEC_ID_TIMED_ID3 },

701 { 0 },

702 };

703

704 /* descriptor present */

705 static const StreamType DESC_types[] = {

706 { 0x6a, AVMEDIA_TYPE_AUDIO, AV_CODEC_ID_AC3 }, /* AC-3 descriptor */

707 { 0x7a, AVMEDIA_TYPE_AUDIO, AV_CODEC_ID_EAC3 }, /* E-AC-3 descriptor */

708 { 0x7b, AVMEDIA_TYPE_AUDIO, AV_CODEC_ID_DTS },

709 { 0x56, AVMEDIA_TYPE_SUBTITLE, AV_CODEC_ID_DVB_TELETEXT },

710 { 0x59, AVMEDIA_TYPE_SUBTITLE, AV_CODEC_ID_DVB_SUBTITLE }, /* subtitling descriptor */

711 { 0 },

712 };

713

714 static void mpegts_find_stream_type(AVStream *st,

715 uint32_t stream_type,

716 const StreamType *types)

717 {

718 if (avcodec_is_open(st->codec)) {

719 av_log(NULL, AV_LOG_DEBUG, "cannot set stream info, codec is open\n");

720 return;

721 }

722

723 for (; types->stream_type; types++)

724 if (stream_type == types->stream_type) {

725 st->codec->codec_type = types->codec_type;

726 st->codec->codec_id = types->codec_id;

727 st->request_probe = 0;

728 return;

729 }

730 }

731

732 static int mpegts_set_stream_info(AVStream *st, PESContext *pes,

733 uint32_t stream_type, uint32_t prog_reg_desc)

734 {

735 int old_codec_type = st->codec->codec_type;

736 int old_codec_id = st->codec->codec_id;

737

738 if (avcodec_is_open(st->codec)) {

739 av_log(pes->stream, AV_LOG_DEBUG, "cannot set stream info, codec is open\n");

740 return 0;

741 }

742

743 avpriv_set_pts_info(st, 33, 1, 90000);

744 st->priv_data = pes;

745 st->codec->codec_type = AVMEDIA_TYPE_DATA;

746 st->codec->codec_id = AV_CODEC_ID_NONE;

747 st->need_parsing = AVSTREAM_PARSE_FULL;

748 pes->st = st;

749 pes->stream_type = stream_type;

750

751 av_log(pes->stream, AV_LOG_DEBUG,

752 "stream=%d stream_type=%x pid=%x prog_reg_desc=%.4s\n",

753 st->index, pes->stream_type, pes->pid, (char *)&prog_reg_desc);

754

755 st->codec->codec_tag = pes->stream_type;

756

757 mpegts_find_stream_type(st, pes->stream_type, ISO_types);

758 if ((prog_reg_desc == AV_RL32("HDMV") ||

759 prog_reg_desc == AV_RL32("HDPR")) &&

760 st->codec->codec_id == AV_CODEC_ID_NONE) {

761 mpegts_find_stream_type(st, pes->stream_type, HDMV_types);

762 if (pes->stream_type == 0x83) {

763 // HDMV TrueHD streams also contain an AC3 coded version of the

764 // audio track - add a second stream for this

765 AVStream *sub_st;

766 // priv_data cannot be shared between streams

767 PESContext *sub_pes = av_malloc(sizeof(*sub_pes));

768 if (!sub_pes)

769 return AVERROR(ENOMEM);

770 memcpy(sub_pes, pes, sizeof(*sub_pes));

771

772 sub_st = avformat_new_stream(pes->stream, NULL);

773 if (!sub_st) {

774 av_free(sub_pes);

775 return AVERROR(ENOMEM);

776 }

777

778 sub_st->id = pes->pid;

779 avpriv_set_pts_info(sub_st, 33, 1, 90000);

780 sub_st->priv_data = sub_pes;

781 sub_st->codec->codec_type = AVMEDIA_TYPE_AUDIO;

782 sub_st->codec->codec_id = AV_CODEC_ID_AC3;

783 sub_st->need_parsing = AVSTREAM_PARSE_FULL;

784 sub_pes->sub_st = pes->sub_st = sub_st;

785 }

786 }

787 if (st->codec->codec_id == AV_CODEC_ID_NONE)

788 mpegts_find_stream_type(st, pes->stream_type, MISC_types);

789 if (st->codec->codec_id == AV_CODEC_ID_NONE) {

790 st->codec->codec_id = old_codec_id;

791 st->codec->codec_type = old_codec_type;

792 }

793

794 return 0;

795 }

796

797 static void reset_pes_packet_state(PESContext *pes)

798 {

799 pes->pts = AV_NOPTS_VALUE;

800 pes->dts = AV_NOPTS_VALUE;

801 pes->data_index = 0;

802 pes->flags = 0;

803 av_buffer_unref(&pes->buffer);

804 }

805

806 static void new_pes_packet(PESContext *pes, AVPacket *pkt)

807 {

808 av_init_packet(pkt);

809

810 pkt->buf = pes->buffer;

811 pkt->data = pes->buffer->data;

812 pkt->size = pes->data_index;

813

814 if (pes->total_size != MAX_PES_PAYLOAD &&

815 pes->pes_header_size + pes->data_index != pes->total_size +

816 PES_START_SIZE) {

817 av_log(pes->stream, AV_LOG_WARNING, "PES packet size mismatch\n");

818 pes->flags |= AV_PKT_FLAG_CORRUPT;

819 }

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

821

822 // Separate out the AC3 substream from an HDMV combined TrueHD/AC3 PID

823 if (pes->sub_st && pes->stream_type == 0x83 && pes->extended_stream_id == 0x76)

824 pkt->stream_index = pes->sub_st->index;

825 else

826 pkt->stream_index = pes->st->index;

827 pkt->pts = pes->pts;

828 pkt->dts = pes->dts;

829 /* store position of first TS packet of this PES packet */

830 pkt->pos = pes->ts_packet_pos;

831 pkt->flags = pes->flags;

832

833 pes->buffer = NULL;

834 reset_pes_packet_state(pes);

835 }

836

837 static uint64_t get_ts64(GetBitContext *gb, int bits)

838 {

839 if (get_bits_left(gb) < bits)

840 return AV_NOPTS_VALUE;

841 return get_bits64(gb, bits);

842 }

843

844 static int read_sl_header(PESContext *pes, SLConfigDescr *sl,

845 const uint8_t *buf, int buf_size)

846 {

847 GetBitContext gb;

848 int au_start_flag = 0, au_end_flag = 0, ocr_flag = 0, idle_flag = 0;

849 int padding_flag = 0, padding_bits = 0, inst_bitrate_flag = 0;

850 int dts_flag = -1, cts_flag = -1;

851 int64_t dts = AV_NOPTS_VALUE, cts = AV_NOPTS_VALUE;

852

853 init_get_bits(&gb, buf, buf_size * 8);

854

855 if (sl->use_au_start)

856 au_start_flag = get_bits1(&gb);

857 if (sl->use_au_end)

858 au_end_flag = get_bits1(&gb);

859 if (!sl->use_au_start && !sl->use_au_end)

860 au_start_flag = au_end_flag = 1;

861 if (sl->ocr_len > 0)

862 ocr_flag = get_bits1(&gb);

863 if (sl->use_idle)

864 idle_flag = get_bits1(&gb);

865 if (sl->use_padding)

866 padding_flag = get_bits1(&gb);

867 if (padding_flag)

868 padding_bits = get_bits(&gb, 3);

869

870 if (!idle_flag && (!padding_flag || padding_bits != 0)) {

871 if (sl->packet_seq_num_len)

872 skip_bits_long(&gb, sl->packet_seq_num_len);

873 if (sl->degr_prior_len)

874 if (get_bits1(&gb))

875 skip_bits(&gb, sl->degr_prior_len);

876 if (ocr_flag)

877 skip_bits_long(&gb, sl->ocr_len);

878 if (au_start_flag) {

879 if (sl->use_rand_acc_pt)

880 get_bits1(&gb);

881 if (sl->au_seq_num_len > 0)

882 skip_bits_long(&gb, sl->au_seq_num_len);

883 if (sl->use_timestamps) {

884 dts_flag = get_bits1(&gb);

885 cts_flag = get_bits1(&gb);

886 }

887 }

888 if (sl->inst_bitrate_len)

889 inst_bitrate_flag = get_bits1(&gb);

890 if (dts_flag == 1)

891 dts = get_ts64(&gb, sl->timestamp_len);

892 if (cts_flag == 1)

893 cts = get_ts64(&gb, sl->timestamp_len);

894 if (sl->au_len > 0)

895 skip_bits_long(&gb, sl->au_len);

896 if (inst_bitrate_flag)

897 skip_bits_long(&gb, sl->inst_bitrate_len);

898 }

899

900 if (dts != AV_NOPTS_VALUE)

901 pes->dts = dts;

902 if (cts != AV_NOPTS_VALUE)

903 pes->pts = cts;

904

905 if (sl->timestamp_len && sl->timestamp_res)

906 avpriv_set_pts_info(pes->st, sl->timestamp_len, 1, sl->timestamp_res);

907

908 return (get_bits_count(&gb) + 7) >> 3;

909 }

910

911 /* return non zero if a packet could be constructed */

912 static int mpegts_push_data(MpegTSFilter *filter,

913 const uint8_t *buf, int buf_size, int is_start,

914 int64_t pos)

915 {

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

917 MpegTSContext *ts = pes->ts;

918 const uint8_t *p;

919 int len, code;

920

921 if (!ts->pkt)

922 return 0;

923

924 if (is_start) {

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

926 new_pes_packet(pes, ts->pkt);

927 ts->stop_parse = 1;

928 } else {

929 reset_pes_packet_state(pes);

930 }

931 pes->state = MPEGTS_HEADER;

932 pes->ts_packet_pos = pos;

933 }

934 p = buf;

935 while (buf_size > 0) {

936 switch (pes->state) {

937 case MPEGTS_HEADER:

938 len = PES_START_SIZE - pes->data_index;

939 if (len > buf_size)

940 len = buf_size;

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

942 pes->data_index += len;

943 p += len;

944 buf_size -= len;

945 if (pes->data_index == PES_START_SIZE) {

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

947 * decide */

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

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

950 /* it must be an mpeg2 PES stream */

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

952 av_dlog(pes->stream, "pid=%x pes_code=%#x\n", pes->pid,

953 code);

954

955 if ((pes->st && pes->st->discard == AVDISCARD_ALL &&

956 (!pes->sub_st ||

957 pes->sub_st->discard == AVDISCARD_ALL)) ||

958 code == 0x1be) /* padding_stream */

959 goto skip;

960

961 /* stream not present in PMT */

962 if (!pes->st) {

963 if (ts->skip_changes)

964 goto skip;

965

966 pes->st = avformat_new_stream(ts->stream, NULL);

967 if (!pes->st)

968 return AVERROR(ENOMEM);

969 pes->st->id = pes->pid;

970 mpegts_set_stream_info(pes->st, pes, 0, 0);

971 }

972

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

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

975 * unbounded */

976 if (!pes->total_size)

977 pes->total_size = MAX_PES_PAYLOAD;

978

979 /* allocate pes buffer */

980 pes->buffer = av_buffer_alloc(pes->total_size +

981 FF_INPUT_BUFFER_PADDING_SIZE);

982 if (!pes->buffer)

983 return AVERROR(ENOMEM);

984

985 if (code != 0x1bc && code != 0x1bf && /* program_stream_map, private_stream_2 */

986 code != 0x1f0 && code != 0x1f1 && /* ECM, EMM */

987 code != 0x1ff && code != 0x1f2 && /* program_stream_directory, DSMCC_stream */

988 code != 0x1f8) { /* ITU-T Rec. H.222.1 type E stream */

989 pes->state = MPEGTS_PESHEADER;

990 if (pes->st->codec->codec_id == AV_CODEC_ID_NONE && !pes->st->request_probe) {

991 av_dlog(pes->stream,

992 "pid=%x stream_type=%x probing\n",

993 pes->pid,

994 pes->stream_type);

995 pes->st->request_probe = 1;

996 }

997 } else {

998 pes->state = MPEGTS_PAYLOAD;

999 pes->data_index = 0;

1000 }

1001 } else {

1002 /* otherwise, it should be a table */

1003 /* skip packet */

1004 skip:

1005 pes->state = MPEGTS_SKIP;

1006 continue;

1007 }

1008 }

1009 break;

1010 /**********************************************/

1011 /* PES packing parsing */

1012 case MPEGTS_PESHEADER:

1013 len = PES_HEADER_SIZE - pes->data_index;

1014 if (len < 0)

1015 return AVERROR_INVALIDDATA;

1016 if (len > buf_size)

1017 len = buf_size;

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

1019 pes->data_index += len;

1020 p += len;

1021 buf_size -= len;

1022 if (pes->data_index == PES_HEADER_SIZE) {

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

1024 pes->state = MPEGTS_PESHEADER_FILL;

1025 }

1026 break;

1027 case MPEGTS_PESHEADER_FILL:

1028 len = pes->pes_header_size - pes->data_index;

1029 if (len < 0)

1030 return AVERROR_INVALIDDATA;

1031 if (len > buf_size)

1032 len = buf_size;

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

1034 pes->data_index += len;

1035 p += len;

1036 buf_size -= len;

1037 if (pes->data_index == pes->pes_header_size) {

1038 const uint8_t *r;

1039 unsigned int flags, pes_ext, skip;

1040

1041 flags = pes->header[7];

1042 r = pes->header + 9;

1043 pes->pts = AV_NOPTS_VALUE;

1044 pes->dts = AV_NOPTS_VALUE;

1045 if ((flags & 0xc0) == 0x80) {

1046 pes->dts = pes->pts = ff_parse_pes_pts(r);

1047 r += 5;

1048 } else if ((flags & 0xc0) == 0xc0) {

1049 pes->pts = ff_parse_pes_pts(r);

1050 r += 5;

1051 pes->dts = ff_parse_pes_pts(r);

1052 r += 5;

1053 }

1054 pes->extended_stream_id = -1;

1055 if (flags & 0x01) { /* PES extension */

1056 pes_ext = *r++;

1057 /* Skip PES private data, program packet sequence counter and P-STD buffer */

1058 skip = (pes_ext >> 4) & 0xb;

1059 skip += skip & 0x9;

1060 r += skip;

1061 if ((pes_ext & 0x41) == 0x01 &&

1062 (r + 2) <= (pes->header + pes->pes_header_size)) {

1063 /* PES extension 2 */

1064 if ((r[0] & 0x7f) > 0 && (r[1] & 0x80) == 0)

1065 pes->extended_stream_id = r[1];

1066 }

1067 }

1068

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

1070 pes->state = MPEGTS_PAYLOAD;

1071 pes->data_index = 0;

1072 if (pes->stream_type == 0x12 && buf_size > 0) {

1073 int sl_header_bytes = read_sl_header(pes, &pes->sl, p,

1074 buf_size);

1075 pes->pes_header_size += sl_header_bytes;

1076 p += sl_header_bytes;

1077 buf_size -= sl_header_bytes;

1078 }

1079 if (pes->stream_type == 0x15 && buf_size >= 5) {

1080 /* skip metadata access unit header */

1081 pes->pes_header_size += 5;

1082 p += 5;

1083 buf_size -= 5;

1084 }

1085 if (pes->ts->fix_teletext_pts && pes->st->codec->codec_id == AV_CODEC_ID_DVB_TELETEXT) {

1086 AVProgram *p = NULL;

1087 while ((p = av_find_program_from_stream(pes->stream, p, pes->st->index))) {

1088 if (p->pcr_pid != -1 && p->discard != AVDISCARD_ALL) {

1089 MpegTSFilter *f = pes->ts->pids[p->pcr_pid];

1090 if (f) {

1091 AVStream *st = NULL;

1092 if (f->type == MPEGTS_PES) {

1093 PESContext *pcrpes = f->u.pes_filter.opaque;

1094 if (pcrpes)

1095 st = pcrpes->st;

1096 } else if (f->type == MPEGTS_PCR) {

1097 int i;

1098 for (i = 0; i < p->nb_stream_indexes; i++) {

1099 AVStream *pst = pes->stream->streams[p->stream_index[i]];

1100 if (pst->codec->codec_type == AVMEDIA_TYPE_VIDEO)

1101 st = pst;

1102 }

1103 }

1104 if (f->last_pcr != -1 && st && st->discard != AVDISCARD_ALL) {

1105 // teletext packets do not always have correct timestamps,

1106 // the standard says they should be handled after 40.6 ms at most,

1107 // and the pcr error to this packet should be no more than 100 ms.

1108 // TODO: we should interpolate the PCR, not just use the last one

1109 int64_t pcr = f->last_pcr / 300;

1110 pes->st->pts_wrap_reference = st->pts_wrap_reference;

1111 pes->st->pts_wrap_behavior = st->pts_wrap_behavior;

1112 if (pes->dts == AV_NOPTS_VALUE || pes->dts < pcr) {

1113 pes->pts = pes->dts = pcr;

1114 } else if (pes->dts > pcr + 3654 + 9000) {

1115 pes->pts = pes->dts = pcr + 3654 + 9000;

1116 }

1117 break;

1118 }

1119 }

1120 }

1121 }

1122 }

1123 }

1124 break;

1125 case MPEGTS_PAYLOAD:

1126 if (pes->buffer) {

1127 if (pes->data_index > 0 &&

1128 pes->data_index + buf_size > pes->total_size) {

1129 new_pes_packet(pes, ts->pkt);

1130 pes->total_size = MAX_PES_PAYLOAD;

1131 pes->buffer = av_buffer_alloc(pes->total_size +

1132 FF_INPUT_BUFFER_PADDING_SIZE);

1133 if (!pes->buffer)

1134 return AVERROR(ENOMEM);

1135 ts->stop_parse = 1;

1136 } else if (pes->data_index == 0 &&

1137 buf_size > pes->total_size) {

1138 // pes packet size is < ts size packet and pes data is padded with 0xff

1139 // not sure if this is legal in ts but see issue #2392

1140 buf_size = pes->total_size;

1141 }

1142 memcpy(pes->buffer->data + pes->data_index, p, buf_size);

1143 pes->data_index += buf_size;

1144 /* emit complete packets with known packet size

1145 * decreases demuxer delay for infrequent packets like subtitles from

1146 * a couple of seconds to milliseconds for properly muxed files.

1147 * total_size is the number of bytes following pes_packet_length

1148 * in the pes header, i.e. not counting the first PES_START_SIZE bytes */

1149 if (!ts->stop_parse && pes->total_size < MAX_PES_PAYLOAD &&

1150 pes->pes_header_size + pes->data_index == pes->total_size + PES_START_SIZE) {

1151 ts->stop_parse = 1;

1152 new_pes_packet(pes, ts->pkt);

1153 }

1154 }

1155 buf_size = 0;

1156 break;

1157 case MPEGTS_SKIP:

1158 buf_size = 0;

1159 break;

1160 }

1161 }

1162

1163 return 0;

1164 }

1165

1166 static PESContext *add_pes_stream(MpegTSContext *ts, int pid, int pcr_pid)

1167 {

1168 MpegTSFilter *tss;

1169 PESContext *pes;

1170

1171 /* if no pid found, then add a pid context */

1172 pes = av_mallocz(sizeof(PESContext));

1173 if (!pes)

1174 return 0;

1175 pes->ts = ts;

1176 pes->stream = ts->stream;

1177 pes->pid = pid;

1178 pes->pcr_pid = pcr_pid;

1179 pes->state = MPEGTS_SKIP;

1180 pes->pts = AV_NOPTS_VALUE;

1181 pes->dts = AV_NOPTS_VALUE;

1182 tss = mpegts_open_pes_filter(ts, pid, mpegts_push_data, pes);

1183 if (!tss) {

1184 av_free(pes);

1185 return 0;

1186 }

1187 return pes;

1188 }

1189

1190 #define MAX_LEVEL 4

1191 typedef struct {

1192 AVFormatContext *s;

1193 AVIOContext pb;

1194 Mp4Descr *descr;

1195 Mp4Descr *active_descr;

1196 int descr_count;

1197 int max_descr_count;

1198 int level;

1199 int predefined_SLConfigDescriptor_seen;

1200 } MP4DescrParseContext;

1201

1202 static int init_MP4DescrParseContext(MP4DescrParseContext *d, AVFormatContext *s,

1203 const uint8_t *buf, unsigned size,

1204 Mp4Descr *descr, int max_descr_count)

1205 {

1206 int ret;

1207 if (size > (1 << 30))

1208 return AVERROR_INVALIDDATA;

1209

1210 if ((ret = ffio_init_context(&d->pb, (unsigned char *)buf, size, 0,

1211 NULL, NULL, NULL, NULL)) < 0)

1212 return ret;

1213

1214 d->s = s;

1215 d->level = 0;

1216 d->descr_count = 0;

1217 d->descr = descr;

1218 d->active_descr = NULL;

1219 d->max_descr_count = max_descr_count;

1220

1221 return 0;

1222 }

1223

1224 static void update_offsets(AVIOContext *pb, int64_t *off, int *len)

1225 {

1226 int64_t new_off = avio_tell(pb);

1227 (*len) -= new_off - *off;

1228 *off = new_off;

1229 }

1230

1231 static int parse_mp4_descr(MP4DescrParseContext *d, int64_t off, int len,

1232 int target_tag);

1233

1234 static int parse_mp4_descr_arr(MP4DescrParseContext *d, int64_t off, int len)

1235 {

1236 while (len > 0) {

1237 int ret = parse_mp4_descr(d, off, len, 0);

1238 if (ret < 0)

1239 return ret;

1240 update_offsets(&d->pb, &off, &len);

1241 }

1242 return 0;

1243 }

1244

1245 static int parse_MP4IODescrTag(MP4DescrParseContext *d, int64_t off, int len)

1246 {

1247 avio_rb16(&d->pb); // ID

1248 avio_r8(&d->pb);

1249 avio_r8(&d->pb);

1250 avio_r8(&d->pb);

1251 avio_r8(&d->pb);

1252 avio_r8(&d->pb);

1253 update_offsets(&d->pb, &off, &len);

1254 return parse_mp4_descr_arr(d, off, len);

1255 }

1256

1257 static int parse_MP4ODescrTag(MP4DescrParseContext *d, int64_t off, int len)

1258 {

1259 int id_flags;

1260 if (len < 2)

1261 return 0;

1262 id_flags = avio_rb16(&d->pb);

1263 if (!(id_flags & 0x0020)) { // URL_Flag

1264 update_offsets(&d->pb, &off, &len);

1265 return parse_mp4_descr_arr(d, off, len); // ES_Descriptor[]

1266 } else {

1267 return 0;

1268 }

1269 }

1270

1271 static int parse_MP4ESDescrTag(MP4DescrParseContext *d, int64_t off, int len)

1272 {

1273 int es_id = 0;

1274 if (d->descr_count >= d->max_descr_count)

1275 return AVERROR_INVALIDDATA;

1276 ff_mp4_parse_es_descr(&d->pb, &es_id);

1277 d->active_descr = d->descr + (d->descr_count++);

1278

1279 d->active_descr->es_id = es_id;

1280 update_offsets(&d->pb, &off, &len);

1281 parse_mp4_descr(d, off, len, MP4DecConfigDescrTag);

1282 update_offsets(&d->pb, &off, &len);

1283 if (len > 0)

1284 parse_mp4_descr(d, off, len, MP4SLDescrTag);

1285 d->active_descr = NULL;

1286 return 0;

1287 }

1288

1289 static int parse_MP4DecConfigDescrTag(MP4DescrParseContext *d, int64_t off,

1290 int len)

1291 {

1292 Mp4Descr *descr = d->active_descr;

1293 if (!descr)

1294 return AVERROR_INVALIDDATA;

1295 d->active_descr->dec_config_descr = av_malloc(len);

1296 if (!descr->dec_config_descr)

1297 return AVERROR(ENOMEM);

1298 descr->dec_config_descr_len = len;

1299 avio_read(&d->pb, descr->dec_config_descr, len);

1300 return 0;

1301 }

1302

1303 static int parse_MP4SLDescrTag(MP4DescrParseContext *d, int64_t off, int len)

1304 {

1305 Mp4Descr *descr = d->active_descr;

1306 int predefined;

1307 if (!descr)

1308 return AVERROR_INVALIDDATA;

1309

1310 predefined = avio_r8(&d->pb);

1311 if (!predefined) {

1312 int lengths;

1313 int flags = avio_r8(&d->pb);

1314 descr->sl.use_au_start = !!(flags & 0x80);

1315 descr->sl.use_au_end = !!(flags & 0x40);

1316 descr->sl.use_rand_acc_pt = !!(flags & 0x20);

1317 descr->sl.use_padding = !!(flags & 0x08);

1318 descr->sl.use_timestamps = !!(flags & 0x04);

1319 descr->sl.use_idle = !!(flags & 0x02);

1320 descr->sl.timestamp_res = avio_rb32(&d->pb);

1321 avio_rb32(&d->pb);

1322 descr->sl.timestamp_len = avio_r8(&d->pb);

1323 if (descr->sl.timestamp_len > 64) {

1324 avpriv_request_sample(NULL, "timestamp_len > 64");

1325 descr->sl.timestamp_len = 64;

1326 return AVERROR_PATCHWELCOME;

1327 }

1328 descr->sl.ocr_len = avio_r8(&d->pb);

1329 descr->sl.au_len = avio_r8(&d->pb);

1330 descr->sl.inst_bitrate_len = avio_r8(&d->pb);

1331 lengths = avio_rb16(&d->pb);

1332 descr->sl.degr_prior_len = lengths >> 12;

1333 descr->sl.au_seq_num_len = (lengths >> 7) & 0x1f;

1334 descr->sl.packet_seq_num_len = (lengths >> 2) & 0x1f;

1335 } else if (!d->predefined_SLConfigDescriptor_seen){

1336 avpriv_report_missing_feature(d->s, "Predefined SLConfigDescriptor");

1337 d->predefined_SLConfigDescriptor_seen = 1;

1338 }

1339 return 0;

1340 }

1341

1342 static int parse_mp4_descr(MP4DescrParseContext *d, int64_t off, int len,

1343 int target_tag)

1344 {

1345 int tag;

1346 int len1 = ff_mp4_read_descr(d->s, &d->pb, &tag);

1347 update_offsets(&d->pb, &off, &len);

1348 if (len < 0 || len1 > len || len1 <= 0) {

1349 av_log(d->s, AV_LOG_ERROR,

1350 "Tag %x length violation new length %d bytes remaining %d\n",

1351 tag, len1, len);

1352 return AVERROR_INVALIDDATA;

1353 }

1354

1355 if (d->level++ >= MAX_LEVEL) {

1356 av_log(d->s, AV_LOG_ERROR, "Maximum MP4 descriptor level exceeded\n");

1357 goto done;

1358 }

1359

1360 if (target_tag && tag != target_tag) {

1361 av_log(d->s, AV_LOG_ERROR, "Found tag %x expected %x\n", tag,

1362 target_tag);

1363 goto done;

1364 }

1365

1366 switch (tag) {

1367 case MP4IODescrTag:

1368 parse_MP4IODescrTag(d, off, len1);

1369 break;

1370 case MP4ODescrTag:

1371 parse_MP4ODescrTag(d, off, len1);

1372 break;

1373 case MP4ESDescrTag:

1374 parse_MP4ESDescrTag(d, off, len1);

1375 break;

1376 case MP4DecConfigDescrTag:

1377 parse_MP4DecConfigDescrTag(d, off, len1);

1378 break;

1379 case MP4SLDescrTag:

1380 parse_MP4SLDescrTag(d, off, len1);

1381 break;

1382 }

1383

1384

1385 done:

1386 d->level--;

1387 avio_seek(&d->pb, off + len1, SEEK_SET);

1388 return 0;

1389 }

1390

1391 static int mp4_read_iods(AVFormatContext *s, const uint8_t *buf, unsigned size,

1392 Mp4Descr *descr, int *descr_count, int max_descr_count)

1393 {

1394 MP4DescrParseContext d;

1395 int ret;

1396

1397 ret = init_MP4DescrParseContext(&d, s, buf, size, descr, max_descr_count);

1398 if (ret < 0)

1399 return ret;

1400

1401 ret = parse_mp4_descr(&d, avio_tell(&d.pb), size, MP4IODescrTag);

1402

1403 *descr_count = d.descr_count;

1404 return ret;

1405 }

1406

1407 static int mp4_read_od(AVFormatContext *s, const uint8_t *buf, unsigned size,

1408 Mp4Descr *descr, int *descr_count, int max_descr_count)

1409 {

1410 MP4DescrParseContext d;

1411 int ret;

1412

1413 ret = init_MP4DescrParseContext(&d, s, buf, size, descr, max_descr_count);

1414 if (ret < 0)

1415 return ret;

1416

1417 ret = parse_mp4_descr_arr(&d, avio_tell(&d.pb), size);

1418

1419 *descr_count = d.descr_count;

1420 return ret;

1421 }

1422

1423 static void m4sl_cb(MpegTSFilter *filter, const uint8_t *section,

1424 int section_len)

1425 {

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

1427 SectionHeader h;

1428 const uint8_t *p, *p_end;

1429 AVIOContext pb;

1430 int mp4_descr_count = 0;

1431 Mp4Descr mp4_descr[MAX_MP4_DESCR_COUNT] = { { 0 } };

1432 int i, pid;

1433 AVFormatContext *s = ts->stream;

1434

1435 p_end = section + section_len - 4;

1436 p = section;

1437 if (parse_section_header(&h, &p, p_end) < 0)

1438 return;

1439 if (h.tid != M4OD_TID)

1440 return;

1441

1442 mp4_read_od(s, p, (unsigned) (p_end - p), mp4_descr, &mp4_descr_count,

1443 MAX_MP4_DESCR_COUNT);

1444

1445 for (pid = 0; pid < NB_PID_MAX; pid++) {

1446 if (!ts->pids[pid])

1447 continue;

1448 for (i = 0; i < mp4_descr_count; i++) {

1449 PESContext *pes;

1450 AVStream *st;

1451 if (ts->pids[pid]->es_id != mp4_descr[i].es_id)

1452 continue;

1453 if (ts->pids[pid]->type != MPEGTS_PES) {

1454 av_log(s, AV_LOG_ERROR, "pid %x is not PES\n", pid);

1455 continue;

1456 }

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

1458 st = pes->st;

1459 if (!st)

1460 continue;

1461

1462 pes->sl = mp4_descr[i].sl;

1463

1464 ffio_init_context(&pb, mp4_descr[i].dec_config_descr,

1465 mp4_descr[i].dec_config_descr_len, 0,

1466 NULL, NULL, NULL, NULL);

1467 ff_mp4_read_dec_config_descr(s, st, &pb);

1468 if (st->codec->codec_id == AV_CODEC_ID_AAC &&

1469 st->codec->extradata_size > 0)

1470 st->need_parsing = 0;

1471 if (st->codec->codec_id == AV_CODEC_ID_H264 &&

1472 st->codec->extradata_size > 0)

1473 st->need_parsing = 0;

1474

1475 if (st->codec->codec_id <= AV_CODEC_ID_NONE) {

1476 // do nothing

1477 } else if (st->codec->codec_id < AV_CODEC_ID_FIRST_AUDIO)

1478 st->codec->codec_type = AVMEDIA_TYPE_VIDEO;

1479 else if (st->codec->codec_id < AV_CODEC_ID_FIRST_SUBTITLE)

1480 st->codec->codec_type = AVMEDIA_TYPE_AUDIO;

1481 else if (st->codec->codec_id < AV_CODEC_ID_FIRST_UNKNOWN)

1482 st->codec->codec_type = AVMEDIA_TYPE_SUBTITLE;

1483 }

1484 }

1485 for (i = 0; i < mp4_descr_count; i++)

1486 av_free(mp4_descr[i].dec_config_descr);

1487 }

1488

1489 int ff_parse_mpeg2_descriptor(AVFormatContext *fc, AVStream *st, int stream_type,

1490 const uint8_t **pp, const uint8_t *desc_list_end,

1491 Mp4Descr *mp4_descr, int mp4_descr_count, int pid,

1492 MpegTSContext *ts)

1493 {

1494 const uint8_t *desc_end;

1495 int desc_len, desc_tag, desc_es_id;

1496 char language[252];

1497 int i;

1498

1499 desc_tag = get8(pp, desc_list_end);

1500 if (desc_tag < 0)

1501 return AVERROR_INVALIDDATA;

1502 desc_len = get8(pp, desc_list_end);

1503 if (desc_len < 0)

1504 return AVERROR_INVALIDDATA;

1505 desc_end = *pp + desc_len;

1506 if (desc_end > desc_list_end)

1507 return AVERROR_INVALIDDATA;

1508

1509 av_dlog(fc, "tag: 0x%02x len=%d\n", desc_tag, desc_len);

1510

1511 if (st->codec->codec_id == AV_CODEC_ID_NONE &&

1512 stream_type == STREAM_TYPE_PRIVATE_DATA)

1513 mpegts_find_stream_type(st, desc_tag, DESC_types);

1514

1515 switch (desc_tag) {

1516 case 0x1E: /* SL descriptor */

1517 desc_es_id = get16(pp, desc_end);

1518 if (ts && ts->pids[pid])

1519 ts->pids[pid]->es_id = desc_es_id;

1520 for (i = 0; i < mp4_descr_count; i++)

1521 if (mp4_descr[i].dec_config_descr_len &&

1522 mp4_descr[i].es_id == desc_es_id) {

1523 AVIOContext pb;

1524 ffio_init_context(&pb, mp4_descr[i].dec_config_descr,

1525 mp4_descr[i].dec_config_descr_len, 0,

1526 NULL, NULL, NULL, NULL);

1527 ff_mp4_read_dec_config_descr(fc, st, &pb);

1528 if (st->codec->codec_id == AV_CODEC_ID_AAC &&

1529 st->codec->extradata_size > 0)

1530 st->need_parsing = 0;

1531 if (st->codec->codec_id == AV_CODEC_ID_MPEG4SYSTEMS)

1532 mpegts_open_section_filter(ts, pid, m4sl_cb, ts, 1);

1533 }

1534 break;

1535 case 0x1F: /* FMC descriptor */

1536 get16(pp, desc_end);

1537 if (mp4_descr_count > 0 &&

1538 (st->codec->codec_id == AV_CODEC_ID_AAC_LATM || st->request_probe > 0) &&

1539 mp4_descr->dec_config_descr_len && mp4_descr->es_id == pid) {

1540 AVIOContext pb;

1541 ffio_init_context(&pb, mp4_descr->dec_config_descr,

1542 mp4_descr->dec_config_descr_len, 0,

1543 NULL, NULL, NULL, NULL);

1544 ff_mp4_read_dec_config_descr(fc, st, &pb);

1545 if (st->codec->codec_id == AV_CODEC_ID_AAC &&

1546 st->codec->extradata_size > 0) {

1547 st->request_probe = st->need_parsing = 0;

1548 st->codec->codec_type = AVMEDIA_TYPE_AUDIO;

1549 }

1550 }

1551 break;

1552 case 0x56: /* DVB teletext descriptor */

1553 {

1554 uint8_t *extradata = NULL;

1555 int language_count = desc_len / 5;

1556

1557 if (desc_len > 0 && desc_len % 5 != 0)

1558 return AVERROR_INVALIDDATA;

1559

1560 if (language_count > 0) {

1561 /* 4 bytes per language code (3 bytes) with comma or NUL byte should fit language buffer */

1562 if (language_count > sizeof(language) / 4) {

1563 language_count = sizeof(language) / 4;

1564 }

1565

1566 if (st->codec->extradata == NULL) {

1567 if (ff_alloc_extradata(st->codec, language_count * 2)) {

1568 return AVERROR(ENOMEM);

1569 }

1570 }

1571

1572 if (st->codec->extradata_size < language_count * 2)

1573 return AVERROR_INVALIDDATA;

1574

1575 extradata = st->codec->extradata;

1576

1577 for (i = 0; i < language_count; i++) {

1578 language[i * 4 + 0] = get8(pp, desc_end);

1579 language[i * 4 + 1] = get8(pp, desc_end);

1580 language[i * 4 + 2] = get8(pp, desc_end);

1581 language[i * 4 + 3] = ',';

1582

1583 memcpy(extradata, *pp, 2);

1584 extradata += 2;

1585

1586 *pp += 2;

1587 }

1588

1589 language[i * 4 - 1] = 0;

1590 av_dict_set(&st->metadata, "language", language, 0);

1591 }

1592 }

1593 break;

1594 case 0x59: /* subtitling descriptor */

1595 {

1596 /* 8 bytes per DVB subtitle substream data:

1597 * ISO_639_language_code (3 bytes),

1598 * subtitling_type (1 byte),

1599 * composition_page_id (2 bytes),

1600 * ancillary_page_id (2 bytes) */

1601 int language_count = desc_len / 8;

1602

1603 if (desc_len > 0 && desc_len % 8 != 0)

1604 return AVERROR_INVALIDDATA;

1605

1606 if (language_count > 1) {

1607 avpriv_request_sample(fc, "DVB subtitles with multiple languages");

1608 }

1609

1610 if (language_count > 0) {

1611 uint8_t *extradata;

1612

1613 /* 4 bytes per language code (3 bytes) with comma or NUL byte should fit language buffer */

1614 if (language_count > sizeof(language) / 4) {

1615 language_count = sizeof(language) / 4;

1616 }

1617

1618 if (st->codec->extradata == NULL) {

1619 if (ff_alloc_extradata(st->codec, language_count * 5)) {

1620 return AVERROR(ENOMEM);

1621 }

1622 }

1623

1624 if (st->codec->extradata_size < language_count * 5)

1625 return AVERROR_INVALIDDATA;

1626

1627 extradata = st->codec->extradata;

1628

1629 for (i = 0; i < language_count; i++) {

1630 language[i * 4 + 0] = get8(pp, desc_end);

1631 language[i * 4 + 1] = get8(pp, desc_end);

1632 language[i * 4 + 2] = get8(pp, desc_end);

1633 language[i * 4 + 3] = ',';

1634

1635 /* hearing impaired subtitles detection using subtitling_type */

1636 switch (*pp[0]) {

1637 case 0x20: /* DVB subtitles (for the hard of hearing) with no monitor aspect ratio criticality */

1638 case 0x21: /* DVB subtitles (for the hard of hearing) for display on 4:3 aspect ratio monitor */

1639 case 0x22: /* DVB subtitles (for the hard of hearing) for display on 16:9 aspect ratio monitor */

1640 case 0x23: /* DVB subtitles (for the hard of hearing) for display on 2.21:1 aspect ratio monitor */

1641 case 0x24: /* DVB subtitles (for the hard of hearing) for display on a high definition monitor */

1642 case 0x25: /* DVB subtitles (for the hard of hearing) with plano-stereoscopic disparity for display on a high definition monitor */

1643 st->disposition |= AV_DISPOSITION_HEARING_IMPAIRED;

1644 break;

1645 }

1646

1647 extradata[4] = get8(pp, desc_end); /* subtitling_type */

1648 memcpy(extradata, *pp, 4); /* composition_page_id and ancillary_page_id */

1649 extradata += 5;

1650

1651 *pp += 4;

1652 }

1653

1654 language[i * 4 - 1] = 0;

1655 av_dict_set(&st->metadata, "language", language, 0);

1656 }

1657 }

1658 break;

1659 case 0x0a: /* ISO 639 language descriptor */

1660 for (i = 0; i + 4 <= desc_len; i += 4) {

1661 language[i + 0] = get8(pp, desc_end);

1662 language[i + 1] = get8(pp, desc_end);

1663 language[i + 2] = get8(pp, desc_end);

1664 language[i + 3] = ',';

1665 switch (get8(pp, desc_end)) {

1666 case 0x01:

1667 st->disposition |= AV_DISPOSITION_CLEAN_EFFECTS;

1668 break;

1669 case 0x02:

1670 st->disposition |= AV_DISPOSITION_HEARING_IMPAIRED;

1671 break;

1672 case 0x03:

1673 st->disposition |= AV_DISPOSITION_VISUAL_IMPAIRED;

1674 break;

1675 }

1676 }

1677 if (i) {

1678 language[i - 1] = 0;

1679 av_dict_set(&st->metadata, "language", language, 0);

1680 }

1681 break;

1682 case 0x05: /* registration descriptor */

1683 st->codec->codec_tag = bytestream_get_le32(pp);

1684 av_dlog(fc, "reg_desc=%.4s\n", (char *)&st->codec->codec_tag);

1685 if (st->codec->codec_id == AV_CODEC_ID_NONE)

1686 mpegts_find_stream_type(st, st->codec->codec_tag, REGD_types);

1687 break;

1688 case 0x52: /* stream identifier descriptor */

1689 st->stream_identifier = 1 + get8(pp, desc_end);

1690 break;

1691 case 0x26: /* metadata descriptor */

1692 if (get16(pp, desc_end) == 0xFFFF)

1693 *pp += 4;

1694 if (get8(pp, desc_end) == 0xFF) {

1695 st->codec->codec_tag = bytestream_get_le32(pp);

1696 if (st->codec->codec_id == AV_CODEC_ID_NONE)

1697 mpegts_find_stream_type(st, st->codec->codec_tag, METADATA_types);

1698 }

1699 break;

1700 default:

1701 break;

1702 }

1703 *pp = desc_end;

1704 return 0;

1705 }

1706

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

1708 {

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

1710 SectionHeader h1, *h = &h1;

1711 PESContext *pes;

1712 AVStream *st;

1713 const uint8_t *p, *p_end, *desc_list_end;

1714 int program_info_length, pcr_pid, pid, stream_type;

1715 int desc_list_len;

1716 uint32_t prog_reg_desc = 0; /* registration descriptor */

1717

1718 int mp4_descr_count = 0;

1719 Mp4Descr mp4_descr[MAX_MP4_DESCR_COUNT] = { { 0 } };

1720 int i;

1721

1722 av_dlog(ts->stream, "PMT: len %i\n", section_len);

1723 hex_dump_debug(ts->stream, section, section_len);

1724

1725 p_end = section + section_len - 4;

1726 p = section;

1727 if (parse_section_header(h, &p, p_end) < 0)

1728 return;

1729

1730 av_dlog(ts->stream, "sid=0x%x sec_num=%d/%d\n",

1731 h->id, h->sec_num, h->last_sec_num);

1732

1733 if (h->tid != PMT_TID)

1734 return;

1735 if (ts->skip_changes)

1736 return;

1737

1738 clear_program(ts, h->id);

1739 pcr_pid = get16(&p, p_end);

1740 if (pcr_pid < 0)

1741 return;

1742 pcr_pid &= 0x1fff;

1743 add_pid_to_pmt(ts, h->id, pcr_pid);

1744 set_pcr_pid(ts->stream, h->id, pcr_pid);

1745

1746 av_dlog(ts->stream, "pcr_pid=0x%x\n", pcr_pid);

1747

1748 program_info_length = get16(&p, p_end);

1749 if (program_info_length < 0)

1750 return;

1751 program_info_length &= 0xfff;

1752 while (program_info_length >= 2) {

1753 uint8_t tag, len;

1754 tag = get8(&p, p_end);

1755 len = get8(&p, p_end);

1756

1757 av_dlog(ts->stream, "program tag: 0x%02x len=%d\n", tag, len);

1758

1759 if (len > program_info_length - 2)

1760 // something else is broken, exit the program_descriptors_loop

1761 break;

1762 program_info_length -= len + 2;

1763 if (tag == 0x1d) { // IOD descriptor

1764 get8(&p, p_end); // scope

1765 get8(&p, p_end); // label

1766 len -= 2;

1767 mp4_read_iods(ts->stream, p, len, mp4_descr + mp4_descr_count,

1768 &mp4_descr_count, MAX_MP4_DESCR_COUNT);

1769 } else if (tag == 0x05 && len >= 4) { // registration descriptor

1770 prog_reg_desc = bytestream_get_le32(&p);

1771 len -= 4;

1772 }

1773 p += len;

1774 }

1775 p += program_info_length;

1776 if (p >= p_end)

1777 goto out;

1778

1779 // stop parsing after pmt, we found header

1780 if (!ts->stream->nb_streams)

1781 ts->stop_parse = 2;

1782

1783 set_pmt_found(ts, h->id);

1784

1785

1786 for (;;) {

1787 st = 0;

1788 pes = NULL;

1789 stream_type = get8(&p, p_end);

1790 if (stream_type < 0)

1791 break;

1792 pid = get16(&p, p_end);

1793 if (pid < 0)

1794 goto out;

1795 pid &= 0x1fff;

1796 if (pid == ts->current_pid)

1797 goto out;

1798

1799 /* now create stream */

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

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

1802 if (!pes->st) {

1803 pes->st = avformat_new_stream(pes->stream, NULL);

1804 if (!pes->st)

1805 goto out;

1806 pes->st->id = pes->pid;

1807 }

1808 st = pes->st;

1809 } else if (stream_type != 0x13) {

1810 if (ts->pids[pid])

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

1812 pes = add_pes_stream(ts, pid, pcr_pid);

1813 if (pes) {

1814 st = avformat_new_stream(pes->stream, NULL);

1815 if (!st)

1816 goto out;

1817 st->id = pes->pid;

1818 }

1819 } else {

1820 int idx = ff_find_stream_index(ts->stream, pid);

1821 if (idx >= 0) {

1822 st = ts->stream->streams[idx];

1823 } else {

1824 st = avformat_new_stream(ts->stream, NULL);

1825 if (!st)

1826 goto out;

1827 st->id = pid;

1828 st->codec->codec_type = AVMEDIA_TYPE_DATA;

1829 }

1830 }

1831

1832 if (!st)

1833 goto out;

1834

1835 if (pes && !pes->stream_type)

1836 mpegts_set_stream_info(st, pes, stream_type, prog_reg_desc);

1837

1838 add_pid_to_pmt(ts, h->id, pid);

1839

1840 ff_program_add_stream_index(ts->stream, h->id, st->index);

1841

1842 desc_list_len = get16(&p, p_end);

1843 if (desc_list_len < 0)

1844 goto out;

1845 desc_list_len &= 0xfff;

1846 desc_list_end = p + desc_list_len;

1847 if (desc_list_end > p_end)

1848 goto out;

1849 for (;;) {

1850 if (ff_parse_mpeg2_descriptor(ts->stream, st, stream_type, &p,

1851 desc_list_end, mp4_descr,

1852 mp4_descr_count, pid, ts) < 0)

1853 break;

1854

1855 if (pes && prog_reg_desc == AV_RL32("HDMV") &&

1856 stream_type == 0x83 && pes->sub_st) {

1857 ff_program_add_stream_index(ts->stream, h->id,

1858 pes->sub_st->index);

1859 pes->sub_st->codec->codec_tag = st->codec->codec_tag;

1860 }

1861 }

1862 p = desc_list_end;

1863 }

1864

1865 if (!ts->pids[pcr_pid])

1866 mpegts_open_pcr_filter(ts, pcr_pid);

1867

1868 out:

1869 for (i = 0; i < mp4_descr_count; i++)

1870 av_free(mp4_descr[i].dec_config_descr);

1871 }

1872

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

1874 {

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

1876 SectionHeader h1, *h = &h1;

1877 const uint8_t *p, *p_end;

1878 int sid, pmt_pid;

1879 AVProgram *program;

1880

1881 av_dlog(ts->stream, "PAT:\n");

1882 hex_dump_debug(ts->stream, section, section_len);

1883

1884 p_end = section + section_len - 4;

1885 p = section;

1886 if (parse_section_header(h, &p, p_end) < 0)

1887 return;

1888 if (h->tid != PAT_TID)

1889 return;

1890 if (ts->skip_changes)

1891 return;

1892

1893 ts->stream->ts_id = h->id;

1894

1895 clear_programs(ts);

1896 for (;;) {

1897 sid = get16(&p, p_end);

1898 if (sid < 0)

1899 break;

1900 pmt_pid = get16(&p, p_end);

1901 if (pmt_pid < 0)

1902 break;

1903 pmt_pid &= 0x1fff;

1904

1905 if (pmt_pid == ts->current_pid)

1906 break;

1907

1908 av_dlog(ts->stream, "sid=0x%x pid=0x%x\n", sid, pmt_pid);

1909

1910 if (sid == 0x0000) {

1911 /* NIT info */

1912 } else {

1913 MpegTSFilter *fil = ts->pids[pmt_pid];

1914 program = av_new_program(ts->stream, sid);

1915 program->program_num = sid;

1916 program->pmt_pid = pmt_pid;

1917 if (fil)

1918 if ( fil->type != MPEGTS_SECTION

1919 || fil->pid != pmt_pid

1920 || fil->u.section_filter.section_cb != pmt_cb)

1921 mpegts_close_filter(ts, ts->pids[pmt_pid]);

1922

1923 if (!ts->pids[pmt_pid])

1924 mpegts_open_section_filter(ts, pmt_pid, pmt_cb, ts, 1);

1925 add_pat_entry(ts, sid);

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

1927 add_pid_to_pmt(ts, sid, pmt_pid);

1928 }

1929 }

1930

1931 if (sid < 0) {

1932 int i,j;

1933 for (j=0; j<ts->stream->nb_programs; j++) {

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

1935 if (ts->prg[i].id == ts->stream->programs[j]->id)

1936 break;

1937 if (i==ts->nb_prg && !ts->skip_clear)

1938 clear_avprogram(ts, ts->stream->programs[j]->id);

1939 }

1940 }

1941 }

1942

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

1944 {

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

1946 SectionHeader h1, *h = &h1;

1947 const uint8_t *p, *p_end, *desc_list_end, *desc_end;

1948 int onid, val, sid, desc_list_len, desc_tag, desc_len, service_type;

1949 char *name, *provider_name;

1950

1951 av_dlog(ts->stream, "SDT:\n");

1952 hex_dump_debug(ts->stream, section, section_len);

1953

1954 p_end = section + section_len - 4;

1955 p = section;

1956 if (parse_section_header(h, &p, p_end) < 0)

1957 return;

1958 if (h->tid != SDT_TID)

1959 return;

1960 if (ts->skip_changes)

1961 return;

1962 onid = get16(&p, p_end);

1963 if (onid < 0)

1964 return;

1965 val = get8(&p, p_end);

1966 if (val < 0)

1967 return;

1968 for (;;) {

1969 sid = get16(&p, p_end);

1970 if (sid < 0)

1971 break;

1972 val = get8(&p, p_end);

1973 if (val < 0)

1974 break;

1975 desc_list_len = get16(&p, p_end);

1976 if (desc_list_len < 0)

1977 break;

1978 desc_list_len &= 0xfff;

1979 desc_list_end = p + desc_list_len;

1980 if (desc_list_end > p_end)

1981 break;

1982 for (;;) {

1983 desc_tag = get8(&p, desc_list_end);

1984 if (desc_tag < 0)

1985 break;

1986 desc_len = get8(&p, desc_list_end);

1987 desc_end = p + desc_len;

1988 if (desc_end > desc_list_end)

1989 break;

1990

1991 av_dlog(ts->stream, "tag: 0x%02x len=%d\n",

1992 desc_tag, desc_len);

1993

1994 switch (desc_tag) {

1995 case 0x48:

1996 service_type = get8(&p, p_end);

1997 if (service_type < 0)

1998 break;

1999 provider_name = getstr8(&p, p_end);

2000 if (!provider_name)

2001 break;

2002 name = getstr8(&p, p_end);

2003 if (name) {

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

2005 if (program) {

2006 av_dict_set(&program->metadata, "service_name", name, 0);

2007 av_dict_set(&program->metadata, "service_provider",

2008 provider_name, 0);

2009 }

2010 }

2011 av_free(name);

2012 av_free(provider_name);

2013 break;

2014 default:

2015 break;

2016 }

2017 p = desc_end;

2018 }

2019 p = desc_list_end;

2020 }

2021 }

2022

2023 static int parse_pcr(int64_t *ppcr_high, int *ppcr_low,

2024 const uint8_t *packet);

2025

2026 /* handle one TS packet */

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

2028 {

2029 MpegTSFilter *tss;

2030 int len, pid, cc, expected_cc, cc_ok, afc, is_start, is_discontinuity,

2031 has_adaptation, has_payload;

2032 const uint8_t *p, *p_end;

2033 int64_t pos;

2034

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

2036 if (pid && discard_pid(ts, pid))

2037 return 0;

2038 is_start = packet[1] & 0x40;

2039 tss = ts->pids[pid];

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

2041 add_pes_stream(ts, pid, -1);

2042 tss = ts->pids[pid];

2043 }

2044 if (!tss)

2045 return 0;

2046 ts->current_pid = pid;

2047

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

2049 if (afc == 0) /* reserved value */

2050 return 0;

2051 has_adaptation = afc & 2;

2052 has_payload = afc & 1;

2053 is_discontinuity = has_adaptation &&

2054 packet[4] != 0 && /* with length > 0 */

2055 (packet[5] & 0x80); /* and discontinuity indicated */

2056

2057 /* continuity check (currently not used) */

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

2059 expected_cc = has_payload ? (tss->last_cc + 1) & 0x0f : tss->last_cc;

2060 cc_ok = pid == 0x1FFF || // null packet PID

2061 is_discontinuity ||

2062 tss->last_cc < 0 ||

2063 expected_cc == cc;

2064

2065 tss->last_cc = cc;

2066 if (!cc_ok) {

2067 av_log(ts->stream, AV_LOG_DEBUG,

2068 "Continuity check failed for pid %d expected %d got %d\n",

2069 pid, expected_cc, cc);

2070 if (tss->type == MPEGTS_PES) {

2071 PESContext *pc = tss->u.pes_filter.opaque;

2072 pc->flags |= AV_PKT_FLAG_CORRUPT;

2073 }

2074 }

2075

2076 if (!has_payload && tss->type != MPEGTS_PCR)

2077 return 0;

2078 p = packet + 4;

2079 if (has_adaptation) {

2080 /* skip adaptation field */

2081 p += p[0] + 1;

2082 }

2083 /* if past the end of packet, ignore */

2084 p_end = packet + TS_PACKET_SIZE;

2085 if (p > p_end || (p == p_end && tss->type != MPEGTS_PCR))

2086 return 0;

2087

2088 pos = avio_tell(ts->stream->pb);

2089 if (pos >= 0) {

2090 av_assert0(pos >= TS_PACKET_SIZE);

2091 ts->pos47_full = pos - TS_PACKET_SIZE;

2092 }

2093

2094 if (tss->type == MPEGTS_SECTION) {

2095 if (is_start) {

2096 /* pointer field present */

2097 len = *p++;

2098 if (p + len > p_end)

2099 return 0;

2100 if (len && cc_ok) {

2101 /* write remaining section bytes */

2102 write_section_data(ts, tss,

2103 p, len, 0);

2104 /* check whether filter has been closed */

2105 if (!ts->pids[pid])

2106 return 0;

2107 }

2108 p += len;

2109 if (p < p_end) {

2110 write_section_data(ts, tss,

2111 p, p_end - p, 1);

2112 }

2113 } else {

2114 if (cc_ok) {

2115 write_section_data(ts, tss,

2116 p, p_end - p, 0);

2117 }

2118 }

2119

2120 // stop find_stream_info from waiting for more streams

2121 // when all programs have received a PMT

2122 if (ts->stream->ctx_flags & AVFMTCTX_NOHEADER) {

2123 int i;

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

2125 if (!ts->prg[i].pmt_found)

2126 break;

2127 }

2128 if (i == ts->nb_prg && ts->nb_prg > 0) {

2129 if (ts->stream->nb_streams > 1 || pos > 100000) {

2130 av_log(ts->stream, AV_LOG_DEBUG, "All programs have pmt, headers found\n");

2131 ts->stream->ctx_flags &= ~AVFMTCTX_NOHEADER;

2132 }

2133 }

2134 }

2135

2136 } else {

2137 int ret;

2138 int64_t pcr_h;

2139 int pcr_l;

2140 if (parse_pcr(&pcr_h, &pcr_l, packet) == 0)

2141 tss->last_pcr = pcr_h * 300 + pcr_l;

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

2143 if (tss->type == MPEGTS_PES) {

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

2145 pos - ts->raw_packet_size)) < 0)

2146 return ret;

2147 }

2148 }

2149

2150 return 0;

2151 }

2152

2153 static void reanalyze(MpegTSContext *ts) {

2154 AVIOContext *pb = ts->stream->pb;

2155 int64_t pos = avio_tell(pb);

2156 if (pos < 0)

2157 return;

2158 pos -= ts->pos47_full;

2159 if (pos == TS_PACKET_SIZE) {

2160 ts->size_stat[0] ++;

2161 } else if (pos == TS_DVHS_PACKET_SIZE) {

2162 ts->size_stat[1] ++;

2163 } else if (pos == TS_FEC_PACKET_SIZE) {

2164 ts->size_stat[2] ++;

2165 }

2166

2167 ts->size_stat_count ++;

2168 if (ts->size_stat_count > SIZE_STAT_THRESHOLD) {

2169 int newsize = 0;

2170 if (ts->size_stat[0] > SIZE_STAT_THRESHOLD) {

2171 newsize = TS_PACKET_SIZE;

2172 } else if (ts->size_stat[1] > SIZE_STAT_THRESHOLD) {

2173 newsize = TS_DVHS_PACKET_SIZE;

2174 } else if (ts->size_stat[2] > SIZE_STAT_THRESHOLD) {

2175 newsize = TS_FEC_PACKET_SIZE;

2176 }

2177 if (newsize && newsize != ts->raw_packet_size) {

2178 av_log(ts->stream, AV_LOG_WARNING, "changing packet size to %d\n", newsize);

2179 ts->raw_packet_size = newsize;

2180 }

2181 ts->size_stat_count = 0;

2182 memset(ts->size_stat, 0, sizeof(ts->size_stat));

2183 }

2184 }

2185

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

2187 * get_packet_size() ?) */

2188 static int mpegts_resync(AVFormatContext *s)

2189 {

2190 AVIOContext *pb = s->pb;

2191 int c, i;

2192

2193 for (i = 0; i < MAX_RESYNC_SIZE; i++) {

2194 c = avio_r8(pb);

2195 if (url_feof(pb))

2196 return AVERROR_EOF;

2197 if (c == 0x47) {

2198 avio_seek(pb, -1, SEEK_CUR);

2199 reanalyze(s->priv_data);

2200 return 0;

2201 }

2202 }

2203 av_log(s, AV_LOG_ERROR,

2204 "max resync size reached, could not find sync byte\n");

2205 /* no sync found */

2206 return AVERROR_INVALIDDATA;

2207 }

2208

2209 /* return AVERROR_something if error or EOF. Return 0 if OK. */

2210 static int read_packet(AVFormatContext *s, uint8_t *buf, int raw_packet_size,

2211 const uint8_t **data)

2212 {

2213 AVIOContext *pb = s->pb;

2214 int len;

2215

2216 for (;;) {

2217 len = ffio_read_indirect(pb, buf, TS_PACKET_SIZE, data);

2218 if (len != TS_PACKET_SIZE)

2219 return len < 0 ? len : AVERROR_EOF;

2220 /* check packet sync byte */

2221 if ((*data)[0] != 0x47) {

2222 /* find a new packet start */

2223 uint64_t pos = avio_tell(pb);

2224 avio_seek(pb, -FFMIN(raw_packet_size, pos), SEEK_CUR);

2225

2226 if (mpegts_resync(s) < 0)

2227 return AVERROR(EAGAIN);

2228 else

2229 continue;

2230 } else {

2231 break;

2232 }

2233 }

2234 return 0;

2235 }

2236

2237 static void finished_reading_packet(AVFormatContext *s, int raw_packet_size)

2238 {

2239 AVIOContext *pb = s->pb;

2240 int skip = raw_packet_size - TS_PACKET_SIZE;

2241 if (skip > 0)

2242 avio_skip(pb, skip);

2243 }

2244

2245 static int handle_packets(MpegTSContext *ts, int nb_packets)

2246 {

2247 AVFormatContext *s = ts->stream;

2248 uint8_t packet[TS_PACKET_SIZE + FF_INPUT_BUFFER_PADDING_SIZE];

2249 const uint8_t *data;

2250 int packet_num, ret = 0;

2251

2252 if (avio_tell(s->pb) != ts->last_pos) {

2253 int i;

2254 av_dlog(ts->stream, "Skipping after seek\n");

2255 /* seek detected, flush pes buffer */

2256 for (i = 0; i < NB_PID_MAX; i++) {

2257 if (ts->pids[i]) {

2258 if (ts->pids[i]->type == MPEGTS_PES) {

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

2260 av_buffer_unref(&pes->buffer);

2261 pes->data_index = 0;

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

2263 }

2264 ts->pids[i]->last_cc = -1;

2265 ts->pids[i]->last_pcr = -1;

2266 }

2267 }

2268 }

2269

2270 ts->stop_parse = 0;

2271 packet_num = 0;

2272 memset(packet + TS_PACKET_SIZE, 0, FF_INPUT_BUFFER_PADDING_SIZE);

2273 for (;;) {

2274 packet_num++;

2275 if (nb_packets != 0 && packet_num >= nb_packets ||

2276 ts->stop_parse > 1) {

2277 ret = AVERROR(EAGAIN);

2278 break;

2279 }

2280 if (ts->stop_parse > 0)

2281 break;

2282

2283 ret = read_packet(s, packet, ts->raw_packet_size, &data);

2284 if (ret != 0)

2285 break;

2286 ret = handle_packet(ts, data);

2287 finished_reading_packet(s, ts->raw_packet_size);

2288 if (ret != 0)

2289 break;

2290 }

2291 ts->last_pos = avio_tell(s->pb);

2292 return ret;

2293 }

2294

2295 static int mpegts_probe(AVProbeData *p)

2296 {

2297 const int size = p->buf_size;

2298 int maxscore = 0;

2299 int sumscore = 0;

2300 int i;

2301 int check_count = size / TS_FEC_PACKET_SIZE;

2302 #define CHECK_COUNT 10

2303 #define CHECK_BLOCK 100

2304

2305 if (check_count < CHECK_COUNT)

2306 return AVERROR_INVALIDDATA;

2307

2308 for (i = 0; i<check_count; i+=CHECK_BLOCK) {

2309 int left = FFMIN(check_count - i, CHECK_BLOCK);

2310 int score = analyze(p->buf + TS_PACKET_SIZE *i, TS_PACKET_SIZE *left, TS_PACKET_SIZE , NULL);

2311 int dvhs_score = analyze(p->buf + TS_DVHS_PACKET_SIZE*i, TS_DVHS_PACKET_SIZE*left, TS_DVHS_PACKET_SIZE, NULL);

2312 int fec_score = analyze(p->buf + TS_FEC_PACKET_SIZE *i, TS_FEC_PACKET_SIZE *left, TS_FEC_PACKET_SIZE , NULL);

2313 score = FFMAX3(score, dvhs_score, fec_score);

2314 sumscore += score;

2315 maxscore = FFMAX(maxscore, score);

2316 }

2317

2318 sumscore = sumscore * CHECK_COUNT / check_count;

2319 maxscore = maxscore * CHECK_COUNT / CHECK_BLOCK;

2320

2321 av_dlog(0, "TS score: %d %d\n", sumscore, maxscore);

2322

2323 if (sumscore > 6) return AVPROBE_SCORE_MAX + sumscore - CHECK_COUNT;

2324 else if (maxscore > 6) return AVPROBE_SCORE_MAX/2 + sumscore - CHECK_COUNT;

2325 else

2326 return AVERROR_INVALIDDATA;

2327 }

2328

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

2330 * (-1) if not available */

2331 static int parse_pcr(int64_t *ppcr_high, int *ppcr_low, const uint8_t *packet)

2332 {

2333 int afc, len, flags;

2334 const uint8_t *p;

2335 unsigned int v;

2336

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

2338 if (afc <= 1)

2339 return AVERROR_INVALIDDATA;

2340 p = packet + 4;

2341 len = p[0];

2342 p++;

2343 if (len == 0)

2344 return AVERROR_INVALIDDATA;

2345 flags = *p++;

2346 len--;

2347 if (!(flags & 0x10))

2348 return AVERROR_INVALIDDATA;

2349 if (len < 6)

2350 return AVERROR_INVALIDDATA;

2351 v = AV_RB32(p);

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

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

2354 return 0;

2355 }

2356

2357 static void seek_back(AVFormatContext *s, AVIOContext *pb, int64_t pos) {

2358

2359 /* NOTE: We attempt to seek on non-seekable files as well, as the

2360 * probe buffer usually is big enough. Only warn if the seek failed

2361 * on files where the seek should work. */

2362 if (avio_seek(pb, pos, SEEK_SET) < 0)

2363 av_log(s, pb->seekable ? AV_LOG_ERROR : AV_LOG_INFO, "Unable to seek back to the start\n");

2364 }

2365

2366 static int mpegts_read_header(AVFormatContext *s)

2367 {

2368 MpegTSContext *ts = s->priv_data;

2369 AVIOContext *pb = s->pb;

2370 uint8_t buf[8 * 1024] = {0};

2371 int len;

2372 int64_t pos;

2373

2374 ffio_ensure_seekback(pb, s->probesize);

2375

2376 /* read the first 8192 bytes to get packet size */

2377 pos = avio_tell(pb);

2378 len = avio_read(pb, buf, sizeof(buf));

2379 ts->raw_packet_size = get_packet_size(buf, len);

2380 if (ts->raw_packet_size <= 0) {

2381 av_log(s, AV_LOG_WARNING, "Could not detect TS packet size, defaulting to non-FEC/DVHS\n");

2382 ts->raw_packet_size = TS_PACKET_SIZE;

2383 }

2384 ts->stream = s;

2385 ts->auto_guess = 0;

2386

2387 if (s->iformat == &ff_mpegts_demuxer) {

2388 /* normal demux */

2389

2390 /* first do a scan to get all the services */

2391 seek_back(s, pb, pos);

2392

2393 mpegts_open_section_filter(ts, SDT_PID, sdt_cb, ts, 1);

2394

2395 mpegts_open_section_filter(ts, PAT_PID, pat_cb, ts, 1);

2396

2397 handle_packets(ts, s->probesize / ts->raw_packet_size);

2398 /* if could not find service, enable auto_guess */

2399

2400 ts->auto_guess = 1;

2401

2402 av_dlog(ts->stream, "tuning done\n");

2403

2404 s->ctx_flags |= AVFMTCTX_NOHEADER;

2405 } else {

2406 AVStream *st;

2407 int pcr_pid, pid, nb_packets, nb_pcrs, ret, pcr_l;

2408 int64_t pcrs[2], pcr_h;

2409 int packet_count[2];

2410 uint8_t packet[TS_PACKET_SIZE];

2411 const uint8_t *data;

2412

2413 /* only read packets */

2414

2415 st = avformat_new_stream(s, NULL);

2416 if (!st)

2417 return AVERROR(ENOMEM);

2418 avpriv_set_pts_info(st, 60, 1, 27000000);

2419 st->codec->codec_type = AVMEDIA_TYPE_DATA;

2420 st->codec->codec_id = AV_CODEC_ID_MPEG2TS;

2421

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

2423 pcr_pid = -1;

2424 nb_pcrs = 0;

2425 nb_packets = 0;

2426 for (;;) {

2427 ret = read_packet(s, packet, ts->raw_packet_size, &data);

2428 if (ret < 0)

2429 return ret;

2430 pid = AV_RB16(data + 1) & 0x1fff;

2431 if ((pcr_pid == -1 || pcr_pid == pid) &&

2432 parse_pcr(&pcr_h, &pcr_l, data) == 0) {

2433 finished_reading_packet(s, ts->raw_packet_size);

2434 pcr_pid = pid;

2435 packet_count[nb_pcrs] = nb_packets;

2436 pcrs[nb_pcrs] = pcr_h * 300 + pcr_l;

2437 nb_pcrs++;

2438 if (nb_pcrs >= 2)

2439 break;

2440 } else {

2441 finished_reading_packet(s, ts->raw_packet_size);

2442 }

2443 nb_packets++;

2444 }

2445

2446 /* NOTE1: the bitrate is computed without the FEC */

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

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

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

2450 s->bit_rate = TS_PACKET_SIZE * 8 * 27e6 / ts->pcr_incr;

2451 st->codec->bit_rate = s->bit_rate;

2452 st->start_time = ts->cur_pcr;

2453 av_dlog(ts->stream, "start=%0.3f pcr=%0.3f incr=%d\n",

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

2455 }

2456

2457 seek_back(s, pb, pos);

2458 return 0;

2459 }

2460

2461 #define MAX_PACKET_READAHEAD ((128 * 1024) / 188)

2462

2463 static int mpegts_raw_read_packet(AVFormatContext *s, AVPacket *pkt)

2464 {

2465 MpegTSContext *ts = s->priv_data;

2466 int ret, i;

2467 int64_t pcr_h, next_pcr_h, pos;

2468 int pcr_l, next_pcr_l;

2469 uint8_t pcr_buf[12];

2470 const uint8_t *data;

2471

2472 if (av_new_packet(pkt, TS_PACKET_SIZE) < 0)

2473 return AVERROR(ENOMEM);

2474 ret = read_packet(s, pkt->data, ts->raw_packet_size, &data);

2475 pkt->pos = avio_tell(s->pb);

2476 if (ret < 0) {

2477 av_free_packet(pkt);

2478 return ret;

2479 }

2480 if (data != pkt->data)

2481 memcpy(pkt->data, data, ts->raw_packet_size);

2482 finished_reading_packet(s, ts->raw_packet_size);

2483 if (ts->mpeg2ts_compute_pcr) {

2484 /* compute exact PCR for each packet */

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

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

2487 pos = avio_tell(s->pb);

2488 for (i = 0; i < MAX_PACKET_READAHEAD; i++) {

2489 avio_seek(s->pb, pos + i * ts->raw_packet_size, SEEK_SET);

2490 avio_read(s->pb, pcr_buf, 12);

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

2492 /* XXX: not precise enough */

2493 ts->pcr_incr =

2494 ((next_pcr_h - pcr_h) * 300 + (next_pcr_l - pcr_l)) /

2495 (i + 1);

2496 break;

2497 }

2498 }

2499 avio_seek(s->pb, pos, SEEK_SET);

2500 /* no next PCR found: we use previous increment */

2501 ts->cur_pcr = pcr_h * 300 + pcr_l;

2502 }

2503 pkt->pts = ts->cur_pcr;

2504 pkt->duration = ts->pcr_incr;

2505 ts->cur_pcr += ts->pcr_incr;

2506 }

2507 pkt->stream_index = 0;

2508 return 0;

2509 }

2510

2511 static int mpegts_read_packet(AVFormatContext *s, AVPacket *pkt)

2512 {

2513 MpegTSContext *ts = s->priv_data;

2514 int ret, i;

2515

2516 pkt->size = -1;

2517 ts->pkt = pkt;

2518 ret = handle_packets(ts, 0);

2519 if (ret < 0) {

2520 av_free_packet(ts->pkt);

2521 /* flush pes data left */

2522 for (i = 0; i < NB_PID_MAX; i++)

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

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

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

2526 new_pes_packet(pes, pkt);

2527 pes->state = MPEGTS_SKIP;

2528 ret = 0;

2529 break;

2530 }

2531 }

2532 }

2533

2534 if (!ret && pkt->size < 0)

2535 ret = AVERROR(EINTR);

2536 return ret;

2537 }

2538

2539 static void mpegts_free(MpegTSContext *ts)

2540 {

2541 int i;

2542

2543 clear_programs(ts);

2544

2545 for (i = 0; i < NB_PID_MAX; i++)

2546 if (ts->pids[i])

2547 mpegts_close_filter(ts, ts->pids[i]);

2548 }

2549

2550 static int mpegts_read_close(AVFormatContext *s)

2551 {

2552 MpegTSContext *ts = s->priv_data;

2553 mpegts_free(ts);

2554 return 0;

2555 }

2556

2557 static av_unused int64_t mpegts_get_pcr(AVFormatContext *s, int stream_index,

2558 int64_t *ppos, int64_t pos_limit)

2559 {

2560 MpegTSContext *ts = s->priv_data;

2561 int64_t pos, timestamp;

2562 uint8_t buf[TS_PACKET_SIZE];

2563 int pcr_l, pcr_pid =

2564 ((PESContext *)s->streams[stream_index]->priv_data)->pcr_pid;

2565 int pos47 = ts->pos47_full % ts->raw_packet_size;

2566 pos =

2567 ((*ppos + ts->raw_packet_size - 1 - pos47) / ts->raw_packet_size) *

2568 ts->raw_packet_size + pos47;

2569 while(pos < pos_limit) {

2570 if (avio_seek(s->pb, pos, SEEK_SET) < 0)

2571 return AV_NOPTS_VALUE;

2572 if (avio_read(s->pb, buf, TS_PACKET_SIZE) != TS_PACKET_SIZE)

2573 return AV_NOPTS_VALUE;

2574 if (buf[0] != 0x47) {

2575 avio_seek(s->pb, -TS_PACKET_SIZE, SEEK_CUR);

2576 if (mpegts_resync(s) < 0)

2577 return AV_NOPTS_VALUE;

2578 pos = avio_tell(s->pb);

2579 continue;

2580 }

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

2582 parse_pcr(&timestamp, &pcr_l, buf) == 0) {

2583 *ppos = pos;

2584 return timestamp;

2585 }

2586 pos += ts->raw_packet_size;

2587 }

2588

2589 return AV_NOPTS_VALUE;

2590 }

2591

2592 static int64_t mpegts_get_dts(AVFormatContext *s, int stream_index,

2593 int64_t *ppos, int64_t pos_limit)

2594 {

2595 MpegTSContext *ts = s->priv_data;

2596 int64_t pos;

2597 int pos47 = ts->pos47_full % ts->raw_packet_size;

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

2599 ff_read_frame_flush(s);

2600 if (avio_seek(s->pb, pos, SEEK_SET) < 0)

2601 return AV_NOPTS_VALUE;

2602 while(pos < pos_limit) {

2603 int ret;

2604 AVPacket pkt;

2605 av_init_packet(&pkt);

2606 ret = av_read_frame(s, &pkt);

2607 if (ret < 0)

2608 return AV_NOPTS_VALUE;

2609 av_free_packet(&pkt);

2610 if (pkt.dts != AV_NOPTS_VALUE && pkt.pos >= 0) {

2611 ff_reduce_index(s, pkt.stream_index);

2612 av_add_index_entry(s->streams[pkt.stream_index], pkt.pos, pkt.dts, 0, 0, AVINDEX_KEYFRAME /* FIXME keyframe? */);

2613 if (pkt.stream_index == stream_index && pkt.pos >= *ppos) {

2614 *ppos = pkt.pos;

2615 return pkt.dts;

2616 }

2617 }

2618 pos = pkt.pos;

2619 }

2620

2621 return AV_NOPTS_VALUE;

2622 }

2623

2624 /**************************************************************/

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

2626

2627 MpegTSContext *ff_mpegts_parse_open(AVFormatContext *s)

2628 {

2629 MpegTSContext *ts;

2630

2631 ts = av_mallocz(sizeof(MpegTSContext));

2632 if (!ts)

2633 return NULL;

2634 /* no stream case, currently used by RTP */

2635 ts->raw_packet_size = TS_PACKET_SIZE;

2636 ts->stream = s;

2637 ts->auto_guess = 1;

2638 mpegts_open_section_filter(ts, SDT_PID, sdt_cb, ts, 1);

2639 mpegts_open_section_filter(ts, PAT_PID, pat_cb, ts, 1);

2640

2641 return ts;

2642 }

2643

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

2645 * packet is output */

2646 int ff_mpegts_parse_packet(MpegTSContext *ts, AVPacket *pkt,

2647 const uint8_t *buf, int len)

2648 {

2649 int len1;

2650

2651 len1 = len;

2652 ts->pkt = pkt;

2653 for (;;) {

2654 ts->stop_parse = 0;

2655 if (len < TS_PACKET_SIZE)

2656 return AVERROR_INVALIDDATA;

2657 if (buf[0] != 0x47) {

2658 buf++;

2659 len--;

2660 } else {

2661 handle_packet(ts, buf);

2662 buf += TS_PACKET_SIZE;

2663 len -= TS_PACKET_SIZE;

2664 if (ts->stop_parse == 1)

2665 break;

2666 }

2667 }

2668 return len1 - len;

2669 }

2670

2671 void ff_mpegts_parse_close(MpegTSContext *ts)

2672 {

2673 mpegts_free(ts);

2674 av_free(ts);

2675 }

2676

2677 AVInputFormat ff_mpegts_demuxer = {

2678 .name = "mpegts",

2679 .long_name = NULL_IF_CONFIG_SMALL("MPEG-TS (MPEG-2 Transport Stream)"),

2680 .priv_data_size = sizeof(MpegTSContext),

2681 .read_probe = mpegts_probe,

2682 .read_header = mpegts_read_header,

2683 .read_packet = mpegts_read_packet,

2684 .read_close = mpegts_read_close,

2685 .read_timestamp = mpegts_get_dts,

2686 .flags = AVFMT_SHOW_IDS | AVFMT_TS_DISCONT,

2687 .priv_class = &mpegts_class,

2688 };

2689

2690 AVInputFormat ff_mpegtsraw_demuxer = {

2691 .name = "mpegtsraw",

2692 .long_name = NULL_IF_CONFIG_SMALL("raw MPEG-TS (MPEG-2 Transport Stream)"),

2693 .priv_data_size = sizeof(MpegTSContext),

2694 .read_header = mpegts_read_header,

2695 .read_packet = mpegts_raw_read_packet,

2696 .read_close = mpegts_read_close,

2697 .read_timestamp = mpegts_get_dts,

2698 .flags = AVFMT_SHOW_IDS | AVFMT_TS_DISCONT,

2699 .priv_class = &mpegtsraw_class,

2700 };

Generated on Sun Jul 20 2014 23:06:04 for FFmpeg by doxygen 1.8.2