FFmpeg: libavformat/mpeg.c Source File

FFmpeg

[フレーム]

libavformat

mpeg.c

Go to the documentation of this file.

1 /*

2 * MPEG-1/2 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 "config_components.h"

24 #include "libavutil/channel_layout.h"

25 #include "avformat.h"

26 #include "avio_internal.h"

27 #include "demux.h"

28 #include "internal.h"

29 #include "mpeg.h"

31 /*********************************************/

32 /* demux code */

34 #define MAX_SYNC_SIZE 100000

36 static int check_pes(const uint8_t *p, const uint8_t *end)

37 {

38 int pes1;

39 int pes2 = (p[3] & 0xC0) == 0x80 &&

40 (p[4] & 0xC0) != 0x40 &&

41 ((p[4] & 0xC0) == 0x00 ||

42 (p[4] & 0xC0) >> 2 == (p[6] & 0xF0));

44 for (p += 3; p < end && *p == 0xFF; p++) ;

45 if ((*p & 0xC0) == 0x40)

46 p += 2;

48 if ((*p & 0xF0) == 0x20)

49 pes1 = p[0] & p[2] & p[4] & 1;

50 else if ((*p & 0xF0) == 0x30)

51 pes1 = p[0] & p[2] & p[4] & p[5] & p[7] & p[9] & 1;

52 else

53 pes1 = *p == 0x0F;

55 return pes1 || pes2;

56 }

58 static int check_pack_header(const uint8_t *buf)

59 {

60 return (buf[1] & 0xC0) == 0x40 || (buf[1] & 0xF0) == 0x20;

61 }

63 static int mpegps_probe(const AVProbeData *p)

64 {

65 uint32_t code = -1;

66 int i;

67 int sys = 0, pspack = 0, priv1 = 0, vid = 0;

68 int audio = 0, invalid = 0, score = 0;

69 int endpes = 0;

71 for (i = 0; i < p->buf_size; i++) {

72 code = (code << 8) + p->buf[i];

73 if ((code & 0xffffff00) == 0x100) {

74 int len = p->buf[i + 1] << 8 | p->buf[i + 2];

75 int pes = endpes <= i && check_pes(p->buf + i, p->buf + p->buf_size);

76 int pack = check_pack_header(p->buf + i);

78 if (len > INT_MAX - i)

79 break;

81 if (code == SYSTEM_HEADER_START_CODE)

82 sys++;

83 else if (code == PACK_START_CODE && pack)

84 pspack++;

85 else if ((code & 0xf0) == VIDEO_ID && pes) {

86 endpes = i + len;

87 vid++;

88 }

89 // skip pes payload to avoid start code emulation for private

90 // and audio streams

91 else if ((code & 0xe0) == AUDIO_ID && pes) {audio++; i+=len;}

92 else if (code == PRIVATE_STREAM_1 && pes) {priv1++; i+=len;}

93 else if (code == 0x1fd && pes) vid++; //VC1

95 else if ((code & 0xf0) == VIDEO_ID && !pes) invalid++;

96 else if ((code & 0xe0) == AUDIO_ID && !pes) invalid++;

97 else if (code == PRIVATE_STREAM_1 && !pes) invalid++;

98 }

99 }

100

101 if (vid + audio > invalid + 1) /* invalid VDR files nd short PES streams */

102 score = AVPROBE_SCORE_EXTENSION / 2;

103

104 // av_log(NULL, AV_LOG_ERROR, "vid:%d aud:%d sys:%d pspack:%d invalid:%d size:%d \n",

105 // vid, audio, sys, pspack, invalid, p->buf_size);

106

107 if (sys > invalid && sys * 9 <= pspack * 10)

108 return (audio > 12 || vid > 3 || pspack > 2) ? AVPROBE_SCORE_EXTENSION + 2

109 : AVPROBE_SCORE_EXTENSION / 2 + (audio + vid + pspack > 1); // 1 more than mp3

110 if (pspack > invalid && (priv1 + vid + audio) * 10 >= pspack * 9)

111 return pspack > 2 ? AVPROBE_SCORE_EXTENSION + 2

112 : AVPROBE_SCORE_EXTENSION / 2; // 1 more than .mpg

113 if ((!!vid ^ !!audio) && (audio > 4 || vid > 1) && !sys &&

114 !pspack && p->buf_size > 2048 && vid + audio > invalid) /* PES stream */

115 return (audio > 12 || vid > 6 + 2 * invalid) ? AVPROBE_SCORE_EXTENSION + 2

116 : AVPROBE_SCORE_EXTENSION / 2;

117

118 // 02-Penguin.flac has sys:0 priv1:0 pspack:0 vid:0 audio:1

119 // mp3_misidentified_2.mp3 has sys:0 priv1:0 pspack:0 vid:0 audio:6

120 // Have\ Yourself\ a\ Merry\ Little\ Christmas.mp3 0 0 0 5 0 1 len:21618

121 return score;

122 }

123

124 typedef struct MpegDemuxContext {

125 int32_t header_state;

126 unsigned char psm_es_type[256];

127 int sofdec;

128 int dvd;

129 int imkh_cctv;

130 int raw_ac3;

131 } MpegDemuxContext;

132

133 static int mpegps_read_header(AVFormatContext *s)

134 {

135 MpegDemuxContext *m = s->priv_data;

136 char buffer[7] = { 0 };

137 int64_t last_pos = avio_tell(s->pb);

138

139 m->header_state = 0xff;

140 s->ctx_flags |= AVFMTCTX_NOHEADER;

141

142 avio_get_str(s->pb, 6, buffer, sizeof(buffer));

143 if (!memcmp("IMKH", buffer, 4)) {

144 m->imkh_cctv = 1;

145 } else if (!memcmp("Sofdec", buffer, 6)) {

146 m->sofdec = 1;

147 } else

148 avio_seek(s->pb, last_pos, SEEK_SET);

149

150 /* no need to do more */

151 return 0;

152 }

153

154 static int64_t get_pts(AVIOContext *pb, int c)

155 {

156 uint8_t buf[5];

157 int ret;

158

159 buf[0] = c < 0 ? avio_r8(pb) : c;

160 ret = avio_read(pb, buf + 1, 4);

161 if (ret < 4)

162 return AV_NOPTS_VALUE;

163

164 return ff_parse_pes_pts(buf);

165 }

166

167 static int find_next_start_code(AVIOContext *pb, int *size_ptr,

168 int32_t *header_state)

169 {

170 unsigned int state, v;

171 int val, n;

172

173 state = *header_state;

174 n = *size_ptr;

175 while (n > 0) {

176 if (avio_feof(pb))

177 break;

178 v = avio_r8(pb);

179 n--;

180 if (state == 0x000001) {

181 state = ((state << 8) | v) & 0xffffff;

182 val = state;

183 goto found;

184 }

185 state = ((state << 8) | v) & 0xffffff;

186 }

187 val = -1;

188

189 found:

190 *header_state = state;

191 *size_ptr = n;

192 return val;

193 }

194

195 /**

196 * Extract stream types from a program stream map

197 * According to ISO/IEC 13818-1 ('MPEG-2 Systems') table 2-35

198 *

199 * @return number of bytes occupied by PSM in the bitstream

200 */

201 static long mpegps_psm_parse(MpegDemuxContext *m, AVIOContext *pb)

202 {

203 int psm_length, ps_info_length, es_map_length;

204

205 psm_length = avio_rb16(pb);

206 avio_r8(pb);

207 avio_r8(pb);

208 ps_info_length = avio_rb16(pb);

209

210 /* skip program_stream_info */

211 avio_skip(pb, ps_info_length);

212 /*es_map_length = */avio_rb16(pb);

213 /* Ignore es_map_length, trust psm_length */

214 es_map_length = psm_length - ps_info_length - 10;

215

216 /* at least one es available? */

217 while (es_map_length >= 4) {

218 unsigned char type = avio_r8(pb);

219 unsigned char es_id = avio_r8(pb);

220 uint16_t es_info_length = avio_rb16(pb);

221

222 /* remember mapping from stream id to stream type */

223 m->psm_es_type[es_id] = type;

224 /* skip program_stream_info */

225 avio_skip(pb, es_info_length);

226 es_map_length -= 4 + es_info_length;

227 }

228 avio_rb32(pb); /* crc32 */

229 return 2 + psm_length;

230 }

231

232 /* read the next PES header. Return its position in ppos

233 * (if not NULL), and its start code, pts and dts.

234 */

235 static int mpegps_read_pes_header(AVFormatContext *s,

236 int64_t *ppos, int *pstart_code,

237 int64_t *ppts, int64_t *pdts)

238 {

239 MpegDemuxContext *m = s->priv_data;

240 int len, size, startcode, c, flags, header_len;

241 int pes_ext, ext2_len, id_ext, skip;

242 int64_t pts, dts;

243 int64_t last_sync = avio_tell(s->pb);

244

245 error_redo:

246 avio_seek(s->pb, last_sync, SEEK_SET);

247 redo:

248 /* next start code (should be immediately after) */

249 m->header_state = 0xff;

250 size = MAX_SYNC_SIZE;

251 startcode = find_next_start_code(s->pb, &size, &m->header_state);

252 last_sync = avio_tell(s->pb);

253 if (startcode < 0) {

254 if (avio_feof(s->pb))

255 return AVERROR_EOF;

256 // FIXME we should remember header_state

257 return FFERROR_REDO;

258 }

259

260 if (startcode == PACK_START_CODE)

261 goto redo;

262 if (startcode == SYSTEM_HEADER_START_CODE)

263 goto redo;

264 if (startcode == PADDING_STREAM) {

265 avio_skip(s->pb, avio_rb16(s->pb));

266 goto redo;

267 }

268 if (startcode == PRIVATE_STREAM_2) {

269 if (!m->sofdec) {

270 /* Need to detect whether this from a DVD or a 'Sofdec' stream */

271 int len = avio_rb16(s->pb);

272 int bytesread = 0;

273 uint8_t *ps2buf = av_malloc(len);

274

275 if (ps2buf) {

276 bytesread = avio_read(s->pb, ps2buf, len);

277

278 if (bytesread != len) {

279 avio_skip(s->pb, len - bytesread);

280 } else {

281 uint8_t *p = 0;

282 if (len >= 6)

283 p = memchr(ps2buf, 'S', len - 5);

284

285 if (p)

286 m->sofdec = !memcmp(p+1, "ofdec", 5);

287

288 m->sofdec -= !m->sofdec;

289

290 if (m->sofdec < 0) {

291 if (len == 980 && ps2buf[0] == 0) {

292 /* PCI structure? */

293 uint32_t startpts = AV_RB32(ps2buf + 0x0d);

294 uint32_t endpts = AV_RB32(ps2buf + 0x11);

295 uint8_t hours = ((ps2buf[0x19] >> 4) * 10) + (ps2buf[0x19] & 0x0f);

296 uint8_t mins = ((ps2buf[0x1a] >> 4) * 10) + (ps2buf[0x1a] & 0x0f);

297 uint8_t secs = ((ps2buf[0x1b] >> 4) * 10) + (ps2buf[0x1b] & 0x0f);

298

299 m->dvd = (hours <= 23 &&

300 mins <= 59 &&

301 secs <= 59 &&

302 (ps2buf[0x19] & 0x0f) < 10 &&

303 (ps2buf[0x1a] & 0x0f) < 10 &&

304 (ps2buf[0x1b] & 0x0f) < 10 &&

305 endpts >= startpts);

306 } else if (len == 1018 && ps2buf[0] == 1) {

307 /* DSI structure? */

308 uint8_t hours = ((ps2buf[0x1d] >> 4) * 10) + (ps2buf[0x1d] & 0x0f);

309 uint8_t mins = ((ps2buf[0x1e] >> 4) * 10) + (ps2buf[0x1e] & 0x0f);

310 uint8_t secs = ((ps2buf[0x1f] >> 4) * 10) + (ps2buf[0x1f] & 0x0f);

311

312 m->dvd = (hours <= 23 &&

313 mins <= 59 &&

314 secs <= 59 &&

315 (ps2buf[0x1d] & 0x0f) < 10 &&

316 (ps2buf[0x1e] & 0x0f) < 10 &&

317 (ps2buf[0x1f] & 0x0f) < 10);

318 }

319 }

320 }

321

322 av_free(ps2buf);

323

324 /* If this isn't a DVD packet or no memory

325 * could be allocated, just ignore it.

326 * If we did, move back to the start of the

327 * packet (plus 'length' field) */

328 if (!m->dvd || avio_skip(s->pb, -(len + 2)) < 0) {

329 /* Skip back failed.

330 * This packet will be lost but that can't be helped

331 * if we can't skip back

332 */

333 goto redo;

334 }

335 } else {

336 /* No memory */

337 avio_skip(s->pb, len);

338 goto redo;

339 }

340 } else if (!m->dvd) {

341 int len = avio_rb16(s->pb);

342 avio_skip(s->pb, len);

343 goto redo;

344 }

345 }

346 if (startcode == PROGRAM_STREAM_MAP) {

347 mpegps_psm_parse(m, s->pb);

348 goto redo;

349 }

350

351 /* find matching stream */

352 if (!((startcode >= 0x1c0 && startcode <= 0x1df) ||

353 (startcode >= 0x1e0 && startcode <= 0x1ef) ||

354 (startcode == 0x1bd) ||

355 (startcode == PRIVATE_STREAM_2) ||

356 (startcode == 0x1fd)))

357 goto redo;

358 if (ppos) {

359 *ppos = avio_tell(s->pb) - 4;

360 }

361 len = avio_rb16(s->pb);

362 pts =

363 dts = AV_NOPTS_VALUE;

364 if (startcode != PRIVATE_STREAM_2)

365 {

366 /* stuffing */

367 for (;;) {

368 if (len < 1)

369 goto error_redo;

370 c = avio_r8(s->pb);

371 len--;

372 /* XXX: for MPEG-1, should test only bit 7 */

373 if (c != 0xff)

374 break;

375 }

376 if ((c & 0xc0) == 0x40) {

377 /* buffer scale & size */

378 avio_r8(s->pb);

379 c = avio_r8(s->pb);

380 len -= 2;

381 }

382 if ((c & 0xe0) == 0x20) {

383 dts =

384 pts = get_pts(s->pb, c);

385 len -= 4;

386 if (c & 0x10) {

387 dts = get_pts(s->pb, -1);

388 len -= 5;

389 }

390 } else if ((c & 0xc0) == 0x80) {

391 /* mpeg 2 PES */

392 flags = avio_r8(s->pb);

393 header_len = avio_r8(s->pb);

394 len -= 2;

395 if (header_len > len)

396 goto error_redo;

397 len -= header_len;

398 if (flags & 0x80) {

399 dts = pts = get_pts(s->pb, -1);

400 header_len -= 5;

401 if (flags & 0x40) {

402 dts = get_pts(s->pb, -1);

403 header_len -= 5;

404 }

405 }

406 if (flags & 0x3f && header_len == 0) {

407 flags &= 0xC0;

408 av_log(s, AV_LOG_WARNING, "Further flags set but no bytes left\n");

409 }

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

411 pes_ext = avio_r8(s->pb);

412 header_len--;

413 /* Skip PES private data, program packet sequence counter

414 * and P-STD buffer */

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

416 skip += skip & 0x9;

417 if (pes_ext & 0x40 || skip > header_len) {

418 av_log(s, AV_LOG_WARNING, "pes_ext %X is invalid\n", pes_ext);

419 pes_ext = skip = 0;

420 }

421 avio_skip(s->pb, skip);

422 header_len -= skip;

423

424 if (pes_ext & 0x01) { /* PES extension 2 */

425 ext2_len = avio_r8(s->pb);

426 header_len--;

427 if ((ext2_len & 0x7f) > 0) {

428 id_ext = avio_r8(s->pb);

429 if ((id_ext & 0x80) == 0)

430 startcode = ((startcode & 0xff) << 8) | id_ext;

431 header_len--;

432 }

433 }

434 }

435 if (header_len < 0)

436 goto error_redo;

437 avio_skip(s->pb, header_len);

438 } else if (c != 0xf)

439 goto redo;

440 }

441

442 if (startcode == PRIVATE_STREAM_1) {

443 int ret = ffio_ensure_seekback(s->pb, 2);

444

445 if (ret < 0)

446 return ret;

447

448 startcode = avio_r8(s->pb);

449 m->raw_ac3 = 0;

450 if (startcode == 0x0b) {

451 if (avio_r8(s->pb) == 0x77) {

452 startcode = 0x80;

453 m->raw_ac3 = 1;

454 avio_skip(s->pb, -2);

455 } else {

456 avio_skip(s->pb, -1);

457 }

458 } else {

459 len--;

460 }

461 }

462 if (len < 0)

463 goto error_redo;

464 if (dts != AV_NOPTS_VALUE && ppos) {

465 int i;

466 for (i = 0; i < s->nb_streams; i++) {

467 if (startcode == s->streams[i]->id &&

468 (s->pb->seekable & AVIO_SEEKABLE_NORMAL) /* index useless on streams anyway */) {

469 ff_reduce_index(s, i);

470 av_add_index_entry(s->streams[i], *ppos, dts, 0, 0,

471 AVINDEX_KEYFRAME /* FIXME keyframe? */);

472 }

473 }

474 }

475

476 *pstart_code = startcode;

477 *ppts = pts;

478 *pdts = dts;

479 return len;

480 }

481

482 static int mpegps_read_packet(AVFormatContext *s,

483 AVPacket *pkt)

484 {

485 MpegDemuxContext *m = s->priv_data;

486 AVStream *st;

487 FFStream *sti;

488 int len, startcode, i, es_type, ret;

489 int pcm_dvd = 0;

490 int request_probe= 0;

491 enum AVCodecID codec_id = AV_CODEC_ID_NONE;

492 enum AVMediaType type;

493 int64_t pts, dts, dummy_pos; // dummy_pos is needed for the index building to work

494

495 redo:

496 len = mpegps_read_pes_header(s, &dummy_pos, &startcode, &pts, &dts);

497 if (len < 0)

498 return len;

499

500 if (startcode >= 0x80 && startcode <= 0xcf) {

501 if (len < 4)

502 goto skip;

503

504 if (!m->raw_ac3) {

505 /* audio: skip header */

506 avio_skip(s->pb, 3);

507 len -= 3;

508 if (startcode >= 0xb0 && startcode <= 0xbf) {

509 /* MLP/TrueHD audio has a 4-byte header */

510 avio_r8(s->pb);

511 len--;

512 } else if (startcode >= 0xa0 && startcode <= 0xaf) {

513 ret = ffio_ensure_seekback(s->pb, 3);

514 if (ret < 0)

515 return ret;

516 pcm_dvd = (avio_rb24(s->pb) & 0xFF) == 0x80;

517 avio_skip(s->pb, -3);

518 }

519 }

520 }

521

522 /* now find stream */

523 for (i = 0; i < s->nb_streams; i++) {

524 st = s->streams[i];

525 if (st->id == startcode)

526 goto found;

527 }

528

529 es_type = m->psm_es_type[startcode & 0xff];

530 if (es_type == STREAM_TYPE_VIDEO_MPEG1) {

531 codec_id = AV_CODEC_ID_MPEG2VIDEO;

532 type = AVMEDIA_TYPE_VIDEO;

533 } else if (es_type == STREAM_TYPE_VIDEO_MPEG2) {

534 codec_id = AV_CODEC_ID_MPEG2VIDEO;

535 type = AVMEDIA_TYPE_VIDEO;

536 } else if (es_type == STREAM_TYPE_AUDIO_MPEG1 ||

537 es_type == STREAM_TYPE_AUDIO_MPEG2) {

538 codec_id = AV_CODEC_ID_MP3;

539 type = AVMEDIA_TYPE_AUDIO;

540 } else if (es_type == STREAM_TYPE_AUDIO_AAC) {

541 codec_id = AV_CODEC_ID_AAC;

542 type = AVMEDIA_TYPE_AUDIO;

543 } else if (es_type == STREAM_TYPE_VIDEO_MPEG4) {

544 codec_id = AV_CODEC_ID_MPEG4;

545 type = AVMEDIA_TYPE_VIDEO;

546 } else if (es_type == STREAM_TYPE_VIDEO_H264) {

547 codec_id = AV_CODEC_ID_H264;

548 type = AVMEDIA_TYPE_VIDEO;

549 } else if (es_type == STREAM_TYPE_VIDEO_HEVC) {

550 codec_id = AV_CODEC_ID_HEVC;

551 type = AVMEDIA_TYPE_VIDEO;

552 } else if (es_type == STREAM_TYPE_VIDEO_VVC) {

553 codec_id = AV_CODEC_ID_VVC;

554 type = AVMEDIA_TYPE_VIDEO;

555 } else if (es_type == STREAM_TYPE_AUDIO_AC3) {

556 codec_id = AV_CODEC_ID_AC3;

557 type = AVMEDIA_TYPE_AUDIO;

558 } else if (es_type == 0x90) {

559 codec_id = AV_CODEC_ID_PCM_ALAW;

560 type = AVMEDIA_TYPE_AUDIO;

561 } else if (m->imkh_cctv && es_type == 0x91) {

562 codec_id = AV_CODEC_ID_PCM_MULAW;

563 type = AVMEDIA_TYPE_AUDIO;

564 } else if (startcode >= 0x1e0 && startcode <= 0x1ef) {

565 static const unsigned char avs_seqh[4] = { 0, 0, 1, 0xb0 };

566 unsigned char buf[8];

567

568 avio_read(s->pb, buf, 8);

569 avio_seek(s->pb, -8, SEEK_CUR);

570 if (!memcmp(buf, avs_seqh, 4) && (buf[6] != 0 || buf[7] != 1))

571 codec_id = AV_CODEC_ID_CAVS;

572 else

573 request_probe= 1;

574 type = AVMEDIA_TYPE_VIDEO;

575 } else if (startcode == PRIVATE_STREAM_2) {

576 type = AVMEDIA_TYPE_DATA;

577 codec_id = AV_CODEC_ID_DVD_NAV;

578 } else if (startcode >= 0x1c0 && startcode <= 0x1df) {

579 type = AVMEDIA_TYPE_AUDIO;

580 if (m->sofdec > 0) {

581 codec_id = AV_CODEC_ID_ADPCM_ADX;

582 // Auto-detect AC-3

583 request_probe = 50;

584 } else if (m->imkh_cctv && startcode == 0x1c0 && len > 80) {

585 codec_id = AV_CODEC_ID_PCM_ALAW;

586 request_probe = 50;

587 } else {

588 codec_id = AV_CODEC_ID_MP2;

589 if (m->imkh_cctv)

590 request_probe = 25;

591 }

592 } else if (startcode >= 0x80 && startcode <= 0x87) {

593 type = AVMEDIA_TYPE_AUDIO;

594 codec_id = AV_CODEC_ID_AC3;

595 } else if ((startcode >= 0x88 && startcode <= 0x8f) ||

596 (startcode >= 0x98 && startcode <= 0x9f)) {

597 /* 0x90 - 0x97 is reserved for SDDS in DVD specs */

598 type = AVMEDIA_TYPE_AUDIO;

599 codec_id = AV_CODEC_ID_DTS;

600 } else if (startcode >= 0xa0 && startcode <= 0xaf) {

601 type = AVMEDIA_TYPE_AUDIO;

602 if (!pcm_dvd) {

603 codec_id = AV_CODEC_ID_MLP;

604 } else {

605 codec_id = AV_CODEC_ID_PCM_DVD;

606 }

607 } else if (startcode >= 0xb0 && startcode <= 0xbf) {

608 type = AVMEDIA_TYPE_AUDIO;

609 codec_id = AV_CODEC_ID_TRUEHD;

610 } else if (startcode >= 0xc0 && startcode <= 0xcf) {

611 /* Used for both AC-3 and E-AC-3 in EVOB files */

612 type = AVMEDIA_TYPE_AUDIO;

613 codec_id = AV_CODEC_ID_AC3;

614 } else if (startcode >= 0x20 && startcode <= 0x3f) {

615 type = AVMEDIA_TYPE_SUBTITLE;

616 codec_id = AV_CODEC_ID_DVD_SUBTITLE;

617 } else if (startcode >= 0xfd55 && startcode <= 0xfd5f) {

618 type = AVMEDIA_TYPE_VIDEO;

619 codec_id = AV_CODEC_ID_VC1;

620 } else {

621 skip:

622 /* skip packet */

623 avio_skip(s->pb, len);

624 goto redo;

625 }

626 /* no stream found: add a new stream */

627 st = avformat_new_stream(s, NULL);

628 if (!st)

629 goto skip;

630 sti = ffstream(st);

631 st->id = startcode;

632 st->codecpar->codec_type = type;

633 st->codecpar->codec_id = codec_id;

634 if ( st->codecpar->codec_id == AV_CODEC_ID_PCM_MULAW

635 || st->codecpar->codec_id == AV_CODEC_ID_PCM_ALAW) {

636 st->codecpar->ch_layout = (AVChannelLayout)AV_CHANNEL_LAYOUT_MONO;

637 st->codecpar->sample_rate = 8000;

638 }

639 sti->request_probe = request_probe;

640 sti->need_parsing = AVSTREAM_PARSE_FULL;

641

642 found:

643 if (st->discard >= AVDISCARD_ALL)

644 goto skip;

645 if (startcode >= 0xa0 && startcode <= 0xaf) {

646 if (st->codecpar->codec_id == AV_CODEC_ID_MLP) {

647 if (len < 6)

648 goto skip;

649 avio_skip(s->pb, 6);

650 len -=6;

651 }

652 }

653 ret = av_get_packet(s->pb, pkt, len);

654

655 pkt->pts = pts;

656 pkt->dts = dts;

657 pkt->pos = dummy_pos;

658 pkt->stream_index = st->index;

659

660 if (s->debug & FF_FDEBUG_TS)

661 av_log(s, AV_LOG_DEBUG, "%d: pts=%0.3f dts=%0.3f size=%d\n",

662 pkt->stream_index, pkt->pts / 90000.0, pkt->dts / 90000.0,

663 pkt->size);

664

665 return (ret < 0) ? ret : 0;

666 }

667

668 static int64_t mpegps_read_dts(AVFormatContext *s, int stream_index,

669 int64_t *ppos, int64_t pos_limit)

670 {

671 int len, startcode;

672 int64_t pos, pts, dts;

673

674 pos = *ppos;

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

676 return AV_NOPTS_VALUE;

677

678 for (;;) {

679 len = mpegps_read_pes_header(s, &pos, &startcode, &pts, &dts);

680 if (len < 0) {

681 if (s->debug & FF_FDEBUG_TS)

682 av_log(s, AV_LOG_DEBUG, "none (ret=%d)\n", len);

683 return AV_NOPTS_VALUE;

684 }

685 if (startcode == s->streams[stream_index]->id &&

686 dts != AV_NOPTS_VALUE) {

687 break;

688 }

689 avio_skip(s->pb, len);

690 }

691 if (s->debug & FF_FDEBUG_TS)

692 av_log(s, AV_LOG_DEBUG, "pos=0x%"PRIx64" dts=0x%"PRIx64" %0.3f\n",

693 pos, dts, dts / 90000.0);

694 *ppos = pos;

695 return dts;

696 }

697

698 const FFInputFormat ff_mpegps_demuxer = {

699 .p.name = "mpeg",

700 .p.long_name = NULL_IF_CONFIG_SMALL("MPEG-PS (MPEG-2 Program Stream)"),

701 .p.flags = AVFMT_SHOW_IDS | AVFMT_TS_DISCONT,

702 .priv_data_size = sizeof(MpegDemuxContext),

703 .read_probe = mpegps_probe,

704 .read_header = mpegps_read_header,

705 .read_packet = mpegps_read_packet,

706 .read_timestamp = mpegps_read_dts,

707 };

708

709 #if CONFIG_VOBSUB_DEMUXER

710

711 #include "subtitles.h"

712 #include "libavutil/avassert.h"

713 #include "libavutil/bprint.h"

714 #include "libavutil/opt.h"

715

716 #define REF_STRING "# VobSub index file,"

717 #define MAX_LINE_SIZE 2048

718

719 typedef struct VobSubDemuxContext {

720 const AVClass *class;

721 AVFormatContext *sub_ctx;

722 FFDemuxSubtitlesQueue q[32];

723 char *sub_name;

724 } VobSubDemuxContext;

725

726 static int vobsub_probe(const AVProbeData *p)

727 {

728 if (!strncmp(p->buf, REF_STRING, sizeof(REF_STRING) - 1))

729 return AVPROBE_SCORE_MAX;

730 return 0;

731 }

732

733 static int vobsub_read_close(AVFormatContext *s)

734 {

735 VobSubDemuxContext *vobsub = s->priv_data;

736 int i;

737

738 for (i = 0; i < s->nb_streams; i++)

739 ff_subtitles_queue_clean(&vobsub->q[i]);

740 avformat_close_input(&vobsub->sub_ctx);

741 return 0;

742 }

743

744 static int vobsub_read_header(AVFormatContext *s)

745 {

746 int i, ret = 0, header_parsed = 0, langidx = 0;

747 VobSubDemuxContext *vobsub = s->priv_data;

748 const AVInputFormat *iformat;

749 size_t fname_len;

750 AVBPrint header;

751 int64_t delay = 0;

752 AVStream *st = NULL;

753 int stream_id = -1;

754 char id[64] = {0};

755 char alt[MAX_LINE_SIZE] = {0};

756

757 if (!vobsub->sub_name) {

758 char *ext;

759 vobsub->sub_name = av_strdup(s->url);

760 if (!vobsub->sub_name) {

761 return AVERROR(ENOMEM);

762 }

763

764 fname_len = strlen(vobsub->sub_name);

765 ext = vobsub->sub_name - 3 + fname_len;

766 if (fname_len < 4 || *(ext - 1) != '.') {

767 av_log(s, AV_LOG_ERROR, "The input index filename is too short "

768 "to guess the associated .SUB file\n");

769 return AVERROR_INVALIDDATA;

770 }

771 memcpy(ext, !strncmp(ext, "IDX", 3) ? "SUB" : "sub", 3);

772 av_log(s, AV_LOG_VERBOSE, "IDX/SUB: %s -> %s\n", s->url, vobsub->sub_name);

773 }

774

775 if (!(iformat = av_find_input_format("mpeg"))) {

776 return AVERROR_DEMUXER_NOT_FOUND;

777 }

778

779 vobsub->sub_ctx = avformat_alloc_context();

780 if (!vobsub->sub_ctx) {

781 return AVERROR(ENOMEM);

782 }

783

784 if ((ret = ff_copy_whiteblacklists(vobsub->sub_ctx, s)) < 0)

785 return ret;

786

787 ret = avformat_open_input(&vobsub->sub_ctx, vobsub->sub_name, iformat, NULL);

788 if (ret < 0) {

789 av_log(s, AV_LOG_ERROR, "Unable to open %s as MPEG subtitles\n", vobsub->sub_name);

790 return ret;

791 }

792

793 av_bprint_init(&header, 0, INT_MAX - AV_INPUT_BUFFER_PADDING_SIZE);

794

795 while (!avio_feof(s->pb)) {

796 char line[MAX_LINE_SIZE];

797 int len = ff_get_line(s->pb, line, sizeof(line));

798

799 if (!len)

800 break;

801

802 line[strcspn(line, "\r\n")] = 0;

803

804 if (!strncmp(line, "id:", 3)) {

805 if (sscanf(line, "id: %63[^,], index: %u", id, &stream_id) != 2) {

806 av_log(s, AV_LOG_WARNING, "Unable to parse index line '%s', "

807 "assuming 'id: und, index: 0'\n", line);

808 strcpy(id, "und");

809 stream_id = 0;

810 }

811

812 if (stream_id >= FF_ARRAY_ELEMS(vobsub->q)) {

813 av_log(s, AV_LOG_ERROR, "Maximum number of subtitles streams reached\n");

814 ret = AVERROR(EINVAL);

815 goto end;

816 }

817

818 header_parsed = 1;

819 alt[0] = '0円';

820 /* We do not create the stream immediately to avoid adding empty

821 * streams. See the following timestamp entry. */

822

823 av_log(s, AV_LOG_DEBUG, "IDX stream[%d] id=%s\n", stream_id, id);

824

825 } else if (!strncmp(line, "timestamp:", 10)) {

826 AVPacket *sub;

827 int hh, mm, ss, ms;

828 int64_t pos, timestamp;

829 const char *p = line + 10;

830

831 if (stream_id == -1) {

832 av_log(s, AV_LOG_ERROR, "Timestamp declared before any stream\n");

833 ret = AVERROR_INVALIDDATA;

834 goto end;

835 }

836

837 if (!st || st->id != stream_id) {

838 st = avformat_new_stream(s, NULL);

839 if (!st) {

840 ret = AVERROR(ENOMEM);

841 goto end;

842 }

843 st->id = stream_id;

844 st->codecpar->codec_type = AVMEDIA_TYPE_SUBTITLE;

845 st->codecpar->codec_id = AV_CODEC_ID_DVD_SUBTITLE;

846 avpriv_set_pts_info(st, 64, 1, 1000);

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

848 if (alt[0])

849 av_dict_set(&st->metadata, "title", alt, 0);

850 }

851

852 if (sscanf(p, "%02d:%02d:%02d:%03d, filepos: %"SCNx64,

853 &hh, &mm, &ss, &ms, &pos) != 5) {

854 av_log(s, AV_LOG_ERROR, "Unable to parse timestamp line '%s', "

855 "abort parsing\n", line);

856 ret = AVERROR_INVALIDDATA;

857 goto end;

858 }

859 timestamp = (hh*3600LL + mm*60LL + ss) * 1000LL + ms + delay;

860 timestamp = av_rescale_q(timestamp, av_make_q(1, 1000), st->time_base);

861

862 sub = ff_subtitles_queue_insert(&vobsub->q[s->nb_streams - 1], "", 0, 0);

863 if (!sub) {

864 ret = AVERROR(ENOMEM);

865 goto end;

866 }

867 sub->pos = pos;

868 sub->pts = timestamp;

869 sub->stream_index = s->nb_streams - 1;

870

871 } else if (!strncmp(line, "alt:", 4)) {

872 const char *p = line + 4;

873

874 while (*p == ' ')

875 p++;

876 av_log(s, AV_LOG_DEBUG, "IDX stream[%d] name=%s\n", stream_id, p);

877 av_strlcpy(alt, p, sizeof(alt));

878 header_parsed = 1;

879

880 } else if (!strncmp(line, "delay:", 6)) {

881 int sign = 1, hh = 0, mm = 0, ss = 0, ms = 0;

882 const char *p = line + 6;

883

884 while (*p == ' ')

885 p++;

886 if (*p == '-' || *p == '+') {

887 sign = *p == '-' ? -1 : 1;

888 p++;

889 }

890 sscanf(p, "%d:%d:%d:%d", &hh, &mm, &ss, &ms);

891 delay = ((hh*3600LL + mm*60LL + ss) * 1000LL + ms) * sign;

892

893 } else if (!strncmp(line, "langidx:", 8)) {

894 const char *p = line + 8;

895

896 if (sscanf(p, "%d", &langidx) != 1)

897 av_log(s, AV_LOG_ERROR, "Invalid langidx specified\n");

898

899 } else if (!header_parsed) {

900 if (line[0] && line[0] != '#')

901 av_bprintf(&header, "%s\n", line);

902 }

903 }

904

905 if (langidx < s->nb_streams)

906 s->streams[langidx]->disposition |= AV_DISPOSITION_DEFAULT;

907

908 for (i = 0; i < s->nb_streams; i++) {

909 vobsub->q[i].sort = SUB_SORT_POS_TS;

910 vobsub->q[i].keep_duplicates = 1;

911 ff_subtitles_queue_finalize(s, &vobsub->q[i]);

912 }

913

914 if (!av_bprint_is_complete(&header)) {

915 ret = AVERROR(ENOMEM);

916 goto end;

917 }

918 for (i = 0; i < s->nb_streams; i++) {

919 AVCodecParameters *par = s->streams[i]->codecpar;

920 ret = ff_alloc_extradata(par, header.len);

921 if (ret < 0) {

922 goto end;

923 }

924 memcpy(par->extradata, header.str, header.len);

925 }

926 end:

927 av_bprint_finalize(&header, NULL);

928 return ret;

929 }

930

931 static int vobsub_read_packet(AVFormatContext *s, AVPacket *pkt)

932 {

933 VobSubDemuxContext *vobsub = s->priv_data;

934 FFDemuxSubtitlesQueue *q;

935 AVIOContext *pb = vobsub->sub_ctx->pb;

936 int ret, psize, total_read = 0, i;

937

938 int64_t min_ts = INT64_MAX;

939 int sid = 0;

940 for (i = 0; i < s->nb_streams; i++) {

941 FFDemuxSubtitlesQueue *tmpq = &vobsub->q[i];

942 int64_t ts;

943 av_assert0(tmpq->nb_subs);

944

945 if (tmpq->current_sub_idx >= tmpq->nb_subs)

946 continue;

947

948 ts = tmpq->subs[tmpq->current_sub_idx]->pts;

949 if (ts < min_ts) {

950 min_ts = ts;

951 sid = i;

952 }

953 }

954 q = &vobsub->q[sid];

955 /* The returned packet will have size zero,

956 * so that it can be directly used with av_grow_packet. */

957 ret = ff_subtitles_queue_read_packet(q, pkt);

958 if (ret < 0)

959 return ret;

960

961 /* compute maximum packet size using the next packet position. This is

962 * useful when the len in the header is non-sense */

963 if (q->current_sub_idx < q->nb_subs) {

964 psize = q->subs[q->current_sub_idx]->pos - pkt->pos;

965 } else {

966 int64_t fsize = avio_size(pb);

967 psize = fsize < 0 ? 0xffff : fsize - pkt->pos;

968 }

969

970 avio_seek(pb, pkt->pos, SEEK_SET);

971

972 do {

973 int n, to_read, startcode;

974 int64_t pts, dts;

975 int64_t old_pos = avio_tell(pb), new_pos;

976 int pkt_size;

977

978 ret = mpegps_read_pes_header(vobsub->sub_ctx, NULL, &startcode, &pts, &dts);

979 if (ret < 0) {

980 if (pkt->size) // raise packet even if incomplete

981 break;

982 return ret;

983 }

984 to_read = ret & 0xffff;

985 new_pos = avio_tell(pb);

986 pkt_size = ret + (new_pos - old_pos);

987

988 /* this prevents reads above the current packet */

989 if (total_read + pkt_size > psize)

990 break;

991 total_read += pkt_size;

992

993 /* the current chunk doesn't match the stream index (unlikely) */

994 if ((startcode & 0x1f) != s->streams[pkt->stream_index]->id)

995 break;

996

997 ret = av_grow_packet(pkt, to_read);

998 if (ret < 0)

999 return ret;

1000

1001 n = avio_read(pb, pkt->data + (pkt->size - to_read), to_read);

1002 if (n < to_read)

1003 pkt->size -= to_read - n;

1004 } while (total_read < psize);

1005

1006 return 0;

1007 }

1008

1009 static int vobsub_read_seek(AVFormatContext *s, int stream_index,

1010 int64_t min_ts, int64_t ts, int64_t max_ts, int flags)

1011 {

1012 VobSubDemuxContext *vobsub = s->priv_data;

1013

1014 /* Rescale requested timestamps based on the first stream (timebase is the

1015 * same for all subtitles stream within a .idx/.sub). Rescaling is done just

1016 * like in avformat_seek_file(). */

1017 if (stream_index == -1 && s->nb_streams != 1) {

1018 int i, ret = 0;

1019 AVRational time_base = s->streams[0]->time_base;

1020 ts = av_rescale_q(ts, AV_TIME_BASE_Q, time_base);

1021 min_ts = av_rescale_rnd(min_ts, time_base.den,

1022 time_base.num * (int64_t)AV_TIME_BASE,

1023 AV_ROUND_UP | AV_ROUND_PASS_MINMAX);

1024 max_ts = av_rescale_rnd(max_ts, time_base.den,

1025 time_base.num * (int64_t)AV_TIME_BASE,

1026 AV_ROUND_DOWN | AV_ROUND_PASS_MINMAX);

1027 for (i = 0; i < s->nb_streams; i++) {

1028 int r = ff_subtitles_queue_seek(&vobsub->q[i], s, stream_index,

1029 min_ts, ts, max_ts, flags);

1030 if (r < 0)

1031 ret = r;

1032 }

1033 return ret;

1034 }

1035

1036 if (stream_index == -1) // only 1 stream

1037 stream_index = 0;

1038 return ff_subtitles_queue_seek(&vobsub->q[stream_index], s, stream_index,

1039 min_ts, ts, max_ts, flags);

1040 }

1041

1042 static const AVOption options[] = {

1043 { "sub_name", "URI for .sub file", offsetof(VobSubDemuxContext, sub_name), AV_OPT_TYPE_STRING, { .str = NULL }, 0, 0, AV_OPT_FLAG_DECODING_PARAM },

1044 { NULL }

1045 };

1046

1047 static const AVClass vobsub_demuxer_class = {

1048 .class_name = "vobsub",

1049 .item_name = av_default_item_name,

1050 .option = options,

1051 .version = LIBAVUTIL_VERSION_INT,

1052 };

1053

1054 const FFInputFormat ff_vobsub_demuxer = {

1055 .p.name = "vobsub",

1056 .p.long_name = NULL_IF_CONFIG_SMALL("VobSub subtitle format"),

1057 .p.flags = AVFMT_SHOW_IDS,

1058 .p.extensions = "idx",

1059 .p.priv_class = &vobsub_demuxer_class,

1060 .priv_data_size = sizeof(VobSubDemuxContext),

1061 .flags_internal = FF_INFMT_FLAG_INIT_CLEANUP,

1062 .read_probe = vobsub_probe,

1063 .read_header = vobsub_read_header,

1064 .read_packet = vobsub_read_packet,

1065 .read_seek2 = vobsub_read_seek,

1066 .read_close = vobsub_read_close,

1067 };

1068 #endif

AV_ROUND_UP

@ AV_ROUND_UP

Round toward +infinity.

Definition: mathematics.h:134

AVMEDIA_TYPE_SUBTITLE

@ AVMEDIA_TYPE_SUBTITLE

Definition: avutil.h:204

MAX_LINE_SIZE

#define MAX_LINE_SIZE

Definition: vf_lut3d.c:546

AV_LOG_WARNING

#define AV_LOG_WARNING

Something somehow does not look correct.

Definition: log.h:186

AVCodecParameters::extradata

uint8_t * extradata

Extra binary data needed for initializing the decoder, codec-dependent.

Definition: codec_par.h:69

AV_CODEC_ID_AC3

@ AV_CODEC_ID_AC3

Definition: codec_id.h:443

SYSTEM_HEADER_START_CODE

#define SYSTEM_HEADER_START_CODE

Definition: mpeg.h:29

mpegps_read_packet

static int mpegps_read_packet(AVFormatContext *s, AVPacket *pkt)

Definition: mpeg.c:482

av_bprint_is_complete

static int av_bprint_is_complete(const AVBPrint *buf)

Test if the print buffer is complete (not truncated).

Definition: bprint.h:218

const char * r

Definition: vf_curves.c:126

AVERROR

Filter the word "frame" indicates either a video frame or a group of audio as stored in an AVFrame structure Format for each input and each output the list of supported formats For video that means pixel format For audio that means channel sample they are references to shared objects When the negotiation mechanism computes the intersection of the formats supported at each end of a all references to both lists are replaced with a reference to the intersection And when a single format is eventually chosen for a link amongst the remaining all references to the list are updated That means that if a filter requires that its input and output have the same format amongst a supported all it has to do is use a reference to the same list of formats query_formats can leave some formats unset and return AVERROR(EAGAIN) to cause the negotiation mechanism toagain later. That can be used by filters with complex requirements to use the format negotiated on one link to set the formats supported on another. Frame references ownership and permissions

opt.h

AVCodecParameters::codec_type

enum AVMediaType codec_type

General type of the encoded data.

Definition: codec_par.h:51

AVFMT_SHOW_IDS

#define AVFMT_SHOW_IDS

Show format stream IDs numbers.

Definition: avformat.h:477

FF_FDEBUG_TS

#define FF_FDEBUG_TS

Definition: avformat.h:1534

STREAM_TYPE_AUDIO_AAC

#define STREAM_TYPE_AUDIO_AAC

Definition: mpeg.h:55

ff_parse_pes_pts

static int64_t ff_parse_pes_pts(const uint8_t *buf)

Parse MPEG-PES five-byte timestamp.

Definition: mpeg.h:69

av_bprint_init

void av_bprint_init(AVBPrint *buf, unsigned size_init, unsigned size_max)

Definition: bprint.c:69

AVCodecParameters

This struct describes the properties of an encoded stream.

Definition: codec_par.h:47

avformat_new_stream

AVStream * avformat_new_stream(AVFormatContext *s, const struct AVCodec *c)

Add a new stream to a media file.

AVERROR_EOF

#define AVERROR_EOF

End of file.

Definition: error.h:57

AVStream::discard

enum AVDiscard discard

Selects which packets can be discarded at will and do not need to be demuxed.

Definition: avformat.h:814

FFDemuxSubtitlesQueue::nb_subs

int nb_subs

number of subtitles packets

Definition: subtitles.h:105

AV_TIME_BASE_Q

#define AV_TIME_BASE_Q

Internal time base represented as fractional value.

Definition: avutil.h:264

int64_t

long long int64_t

Definition: coverity.c:34

av_grow_packet

int av_grow_packet(AVPacket *pkt, int grow_by)

Increase packet size, correctly zeroing padding.

Definition: avpacket.c:121

AV_DISPOSITION_DEFAULT

#define AV_DISPOSITION_DEFAULT

The stream should be chosen by default among other streams of the same type, unless the user has expl...

Definition: avformat.h:621

AV_CODEC_ID_MPEG4

@ AV_CODEC_ID_MPEG4

Definition: codec_id.h:64

STREAM_TYPE_AUDIO_MPEG1

#define STREAM_TYPE_AUDIO_MPEG1

Definition: mpeg.h:51

ff_vobsub_demuxer

const FFInputFormat ff_vobsub_demuxer

STREAM_TYPE_VIDEO_VVC

#define STREAM_TYPE_VIDEO_VVC

Definition: mpeg.h:59

AVPacket::data

uint8_t * data

Definition: packet.h:522

AVOption

AVOption.

Definition: opt.h:346

find_next_start_code

static int find_next_start_code(AVIOContext *pb, int *size_ptr, int32_t *header_state)

Definition: mpeg.c:167

AV_LOG_VERBOSE

#define AV_LOG_VERBOSE

Detailed information.

Definition: log.h:196

AUDIO_ID

#define AUDIO_ID

Definition: mpeg.h:41

AVProbeData::buf_size

int buf_size

Size of buf except extra allocated bytes.

Definition: avformat.h:454

avio_size

int64_t avio_size(AVIOContext *s)

Get the filesize.

Definition: aviobuf.c:322

AV_CODEC_ID_TRUEHD

@ AV_CODEC_ID_TRUEHD

Definition: codec_id.h:484

MpegDemuxContext::dvd

int dvd

Definition: mpeg.c:128

av_malloc

#define av_malloc(s)

Definition: tableprint_vlc.h:30

STREAM_TYPE_AUDIO_MPEG2

#define STREAM_TYPE_AUDIO_MPEG2

Definition: mpeg.h:52

FFDemuxSubtitlesQueue::current_sub_idx

int current_sub_idx

current position for the read packet callback

Definition: subtitles.h:107

AVINDEX_KEYFRAME

#define AVINDEX_KEYFRAME

Definition: avformat.h:610

AVPROBE_SCORE_MAX

#define AVPROBE_SCORE_MAX

maximum score

Definition: avformat.h:463

avformat_close_input

void avformat_close_input(AVFormatContext **s)

Close an opened input AVFormatContext.

Definition: demux.c:362

avpriv_set_pts_info

void avpriv_set_pts_info(AVStream *st, int pts_wrap_bits, unsigned int pts_num, unsigned int pts_den)

Set the time base and wrapping info for a given stream.

Definition: avformat.c:853

ffstream

static av_always_inline FFStream * ffstream(AVStream *st)

Definition: internal.h:417

av_add_index_entry

int av_add_index_entry(AVStream *st, int64_t pos, int64_t timestamp, int size, int distance, int flags)

Add an index entry into a sorted list.

Definition: seek.c:120

read_close

static av_cold int read_close(AVFormatContext *ctx)

Definition: libcdio.c:143

avio_tell

static av_always_inline int64_t avio_tell(AVIOContext *s)

ftell() equivalent for AVIOContext.

Definition: avio.h:494

val

static double val(void *priv, double ch)

Definition: aeval.c:78

type

it s the only field you need to keep assuming you have a context There is some magic you don t need to care about around this just let it vf type

Definition: writing_filters.txt:86

pts

static int64_t pts

Definition: transcode_aac.c:643

AV_CODEC_ID_MP3

@ AV_CODEC_ID_MP3

preferred ID for decoding MPEG audio layer 1, 2 or 3

Definition: codec_id.h:441

#define ss(width, name, subs,...)

Definition: cbs_vp9.c:202

AVRational::num

int num

Numerator.

Definition: rational.h:59

ff_subtitles_queue_seek

int ff_subtitles_queue_seek(FFDemuxSubtitlesQueue *q, AVFormatContext *s, int stream_index, int64_t min_ts, int64_t ts, int64_t max_ts, int flags)

Update current_sub_idx to emulate a seek.

Definition: subtitles.c:261

avassert.h

avio_rb32

unsigned int avio_rb32(AVIOContext *s)

Definition: aviobuf.c:760

pkt

AVPacket * pkt

Definition: movenc.c:59

AV_LOG_ERROR

#define AV_LOG_ERROR

Something went wrong and cannot losslessly be recovered.

Definition: log.h:180

PROGRAM_STREAM_MAP

#define PROGRAM_STREAM_MAP

Definition: mpeg.h:36

FF_ARRAY_ELEMS

#define FF_ARRAY_ELEMS(a)

Definition: sinewin_tablegen.c:29

AVInputFormat

Definition: avformat.h:548

avformat_open_input

int avformat_open_input(AVFormatContext **ps, const char *url, const AVInputFormat *fmt, AVDictionary **options)

Open an input stream and read the header.

Definition: demux.c:214

read_packet

static int read_packet(void *opaque, uint8_t *buf, int buf_size)

Definition: avio_read_callback.c:41

STREAM_TYPE_AUDIO_AC3

#define STREAM_TYPE_AUDIO_AC3

Definition: mpeg.h:62

STREAM_TYPE_VIDEO_MPEG4

#define STREAM_TYPE_VIDEO_MPEG4

Definition: mpeg.h:56

#define s(width, name)

Definition: cbs_vp9.c:198

AVInputFormat::name

const char * name

A comma separated list of short names for the format.

Definition: avformat.h:553

AVProbeData::buf

unsigned char * buf

Buffer must have AVPROBE_PADDING_SIZE of extra allocated bytes filled with zero.

Definition: avformat.h:453

AVMEDIA_TYPE_AUDIO

@ AVMEDIA_TYPE_AUDIO

Definition: avutil.h:202

AV_CODEC_ID_MP2

@ AV_CODEC_ID_MP2

Definition: codec_id.h:440

get_pts

static int64_t get_pts(AVIOContext *pb, int c)

Definition: mpeg.c:154

av_assert0

#define av_assert0(cond)

assert() equivalent, that is always enabled.

Definition: avassert.h:40

AV_LOG_DEBUG

#define AV_LOG_DEBUG

Stuff which is only useful for libav* developers.

Definition: log.h:201

nb_streams

static int nb_streams

Definition: ffprobe.c:383

av_rescale_q

int64_t av_rescale_q(int64_t a, AVRational bq, AVRational cq)

Rescale a 64-bit integer by 2 rational numbers.

Definition: mathematics.c:142

AV_CODEC_ID_PCM_MULAW

@ AV_CODEC_ID_PCM_MULAW

Definition: codec_id.h:334

codec_id

enum AVCodecID codec_id

Definition: vaapi_decode.c:387

AV_CODEC_ID_PCM_DVD

@ AV_CODEC_ID_PCM_DVD

Definition: codec_id.h:347

AVMEDIA_TYPE_DATA

@ AVMEDIA_TYPE_DATA

Opaque data information usually continuous.

Definition: avutil.h:203

STREAM_TYPE_VIDEO_MPEG1

#define STREAM_TYPE_VIDEO_MPEG1

Definition: mpeg.h:49

fsize

static int64_t fsize(FILE *f)

Definition: audiomatch.c:29

ff_subtitles_queue_read_packet

int ff_subtitles_queue_read_packet(FFDemuxSubtitlesQueue *q, AVPacket *pkt)

Generic read_packet() callback for subtitles demuxers using this queue system.

Definition: subtitles.c:222

AV_CODEC_ID_H264

@ AV_CODEC_ID_H264

Definition: codec_id.h:79

AV_ROUND_PASS_MINMAX

@ AV_ROUND_PASS_MINMAX

Flag telling rescaling functions to pass INT64_MIN/MAX through unchanged, avoiding special cases for ...

Definition: mathematics.h:159

AV_CODEC_ID_DVD_NAV

@ AV_CODEC_ID_DVD_NAV

Definition: codec_id.h:587

if(ret)

Definition: filter_design.txt:179

AVERROR_DEMUXER_NOT_FOUND

#define AVERROR_DEMUXER_NOT_FOUND

Demuxer not found.

Definition: error.h:55

FF_INFMT_FLAG_INIT_CLEANUP

#define FF_INFMT_FLAG_INIT_CLEANUP

For an FFInputFormat with this flag set read_close() needs to be called by the caller upon read_heade...

Definition: demux.h:35

SUB_SORT_POS_TS

@ SUB_SORT_POS_TS

sort by position, then timestamps

Definition: subtitles.h:32

FFStream::need_parsing

enum AVStreamParseType need_parsing

Definition: internal.h:386

AVDISCARD_ALL

@ AVDISCARD_ALL

discard all

Definition: defs.h:219

AVFormatContext

Format I/O context.

Definition: avformat.h:1255

AV_CODEC_ID_PCM_ALAW

@ AV_CODEC_ID_PCM_ALAW

Definition: codec_id.h:335

internal.h

mpegps_read_header

static int mpegps_read_header(AVFormatContext *s)

Definition: mpeg.c:133

AVStream::codecpar

AVCodecParameters * codecpar

Codec parameters associated with this stream.

Definition: avformat.h:766

LIBAVUTIL_VERSION_INT

#define LIBAVUTIL_VERSION_INT

Definition: version.h:85

read_header

static int read_header(FFV1Context *f)

Definition: ffv1dec.c:550

AVClass

Describe the class of an AVClass context structure.

Definition: log.h:66

AVStream::time_base

AVRational time_base

This is the fundamental unit of time (in seconds) in terms of which frame timestamps are represented.

Definition: avformat.h:782

NULL

#define NULL

Definition: coverity.c:32

AVFMTCTX_NOHEADER

#define AVFMTCTX_NOHEADER

signal that no header is present (streams are added dynamically)

Definition: avformat.h:1206

check_pes

static int check_pes(const uint8_t *p, const uint8_t *end)

Definition: mpeg.c:36

AVRational

Rational number (pair of numerator and denominator).

Definition: rational.h:58

ff_copy_whiteblacklists

int ff_copy_whiteblacklists(AVFormatContext *dst, const AVFormatContext *src)

Copies the whilelists from one context to the other.

Definition: avformat.c:898

AV_CODEC_ID_DVD_SUBTITLE

@ AV_CODEC_ID_DVD_SUBTITLE

Definition: codec_id.h:549

av_default_item_name

const char * av_default_item_name(void *ptr)

Return the context name.

Definition: log.c:237

AVProbeData

This structure contains the data a format has to probe a file.

Definition: avformat.h:451

ff_mpegps_demuxer

const FFInputFormat ff_mpegps_demuxer

Definition: mpeg.c:698

AVStream::metadata

AVDictionary * metadata

Definition: avformat.h:823

state

static struct @385 state

PACK_START_CODE

#define PACK_START_CODE

Definition: mpeg.h:28

ff_subtitles_queue_insert

AVPacket * ff_subtitles_queue_insert(FFDemuxSubtitlesQueue *q, const uint8_t *event, size_t len, int merge)

Insert a new subtitle event.

Definition: subtitles.c:109

AVCodecParameters::ch_layout

AVChannelLayout ch_layout

Audio only.

Definition: codec_par.h:180

MpegDemuxContext::sofdec

int sofdec

Definition: mpeg.c:127

Undefined Behavior In the C some operations are like signed integer dereferencing freed accessing outside allocated Undefined Behavior must not occur in a C it is not safe even if the output of undefined operations is unused The unsafety may seem nit picking but Optimizing compilers have in fact optimized code on the assumption that no undefined Behavior occurs Optimizing code based on wrong assumptions can and has in some cases lead to effects beyond the output of computations The signed integer overflow problem in speed critical code Code which is highly optimized and works with signed integers sometimes has the problem that often the output of the computation does not c

Definition: undefined.txt:32

AVPROBE_SCORE_EXTENSION

#define AVPROBE_SCORE_EXTENSION

score for file extension

Definition: avformat.h:461

AVCodecParameters::sample_rate

int sample_rate

Audio only.

Definition: codec_par.h:184

AVCodecID

Identify the syntax and semantics of the bitstream.

Definition: codec_id.h:49

AV_CODEC_ID_AAC

@ AV_CODEC_ID_AAC

Definition: codec_id.h:442

AV_ROUND_DOWN

@ AV_ROUND_DOWN

Round toward -infinity.

Definition: mathematics.h:133

av_rescale_rnd

int64_t av_rescale_rnd(int64_t a, int64_t b, int64_t c, enum AVRounding rnd)

Rescale a 64-bit integer with specified rounding.

Definition: mathematics.c:58

options

const OptionDef options[]

AVIOContext

Bytestream IO Context.

Definition: avio.h:160

avio_rb24

unsigned int avio_rb24(AVIOContext *s)

Definition: aviobuf.c:753

MpegDemuxContext::psm_es_type

unsigned char psm_es_type[256]

Definition: mpeg.c:126

AVMediaType

Definition: avutil.h:199

AV_CODEC_ID_ADPCM_ADX

@ AV_CODEC_ID_ADPCM_ADX

Definition: codec_id.h:376

AVPacket::size

int size

Definition: packet.h:523

NULL_IF_CONFIG_SMALL

#define NULL_IF_CONFIG_SMALL(x)

Return NULL if CONFIG_SMALL is true, otherwise the argument without modification.

Definition: internal.h:106

PRIVATE_STREAM_1

#define PRIVATE_STREAM_1

Definition: mpeg.h:37

check_pack_header

static int check_pack_header(const uint8_t *buf)

Definition: mpeg.c:58

avformat_alloc_context

AVFormatContext * avformat_alloc_context(void)

Allocate an AVFormatContext.

Definition: options.c:160

av_bprint_finalize

int av_bprint_finalize(AVBPrint *buf, char **ret_str)

Finalize a print buffer.

Definition: bprint.c:240

STREAM_TYPE_VIDEO_HEVC

#define STREAM_TYPE_VIDEO_HEVC

Definition: mpeg.h:58

AVChannelLayout

An AVChannelLayout holds information about the channel layout of audio data.

Definition: channel_layout.h:303

FFStream

Definition: internal.h:193

AV_CODEC_ID_DTS

@ AV_CODEC_ID_DTS

Definition: codec_id.h:444

avio_get_str

int avio_get_str(AVIOContext *pb, int maxlen, char *buf, int buflen)

Read a string from pb into buf.

Definition: aviobuf.c:865

size

int size

Definition: twinvq_data.h:10344

av_make_q

static AVRational av_make_q(int num, int den)

Create an AVRational.

Definition: rational.h:71

AV_NOPTS_VALUE

#define AV_NOPTS_VALUE

Undefined timestamp value.

Definition: avutil.h:248

AV_RB32

uint64_t_TMPL AV_WL64 unsigned int_TMPL AV_WL32 unsigned int_TMPL AV_WL24 unsigned int_TMPL AV_WL16 uint64_t_TMPL AV_WB64 unsigned int_TMPL AV_RB32

Definition: bytestream.h:96

MpegDemuxContext::header_state

int32_t header_state

Definition: mpeg.c:125

ff_subtitles_queue_finalize

void ff_subtitles_queue_finalize(void *log_ctx, FFDemuxSubtitlesQueue *q)

Set missing durations, sort subtitles by PTS (and then byte position), and drop duplicated events.

Definition: subtitles.c:204

FFDemuxSubtitlesQueue

Definition: subtitles.h:103

FFInputFormat::p

AVInputFormat p

The public AVInputFormat.

Definition: demux.h:41

header

static const uint8_t header[24]

Definition: sdr2.c:68

AVPacket::dts

int64_t dts

Decompression timestamp in AVStream->time_base units; the time at which the packet is decompressed.

Definition: packet.h:521

avio_r8

int avio_r8(AVIOContext *s)

Definition: aviobuf.c:602

STREAM_TYPE_VIDEO_MPEG2

#define STREAM_TYPE_VIDEO_MPEG2

Definition: mpeg.h:50

ffio_ensure_seekback

int ffio_ensure_seekback(AVIOContext *s, int64_t buf_size)

Ensures that the requested seekback buffer size will be available.

Definition: aviobuf.c:1022

AV_CODEC_ID_VVC

@ AV_CODEC_ID_VVC

Definition: codec_id.h:250

ff_subtitles_queue_clean

void ff_subtitles_queue_clean(FFDemuxSubtitlesQueue *q)

Remove and destroy all the subtitles packets.

Definition: subtitles.c:313

mpeg.h

line

Definition: graph2dot.c:48

MpegDemuxContext::imkh_cctv

int imkh_cctv

Definition: mpeg.c:129

MpegDemuxContext::raw_ac3

int raw_ac3

Definition: mpeg.c:130

FFERROR_REDO

#define FFERROR_REDO

Returned by demuxers to indicate that data was consumed but discarded (ignored streams or junk data).

Definition: demux.h:171

iformat

static const AVInputFormat * iformat

Definition: ffprobe.c:359

PRIVATE_STREAM_2

#define PRIVATE_STREAM_2

Definition: mpeg.h:39

bprint.h

AV_CODEC_ID_NONE

@ AV_CODEC_ID_NONE

Definition: codec_id.h:50

#define i(width, name, range_min, range_max)

Definition: cbs_h2645.c:255

AVPacket::pts

int64_t pts

Presentation timestamp in AVStream->time_base units; the time at which the decompressed packet will b...

Definition: packet.h:515

code

and forward the test the status of outputs and forward it to the corresponding return FFERROR_NOT_READY If the filters stores internally one or a few frame for some it can consider them to be part of the FIFO and delay acknowledging a status change accordingly Example code

Definition: filter_design.txt:178

FFDemuxSubtitlesQueue::subs

AVPacket ** subs

array of subtitles packets

Definition: subtitles.h:104

avio_internal.h

AV_TIME_BASE

#define AV_TIME_BASE

Internal time base represented as integer.

Definition: avutil.h:254

AV_CODEC_ID_CAVS

@ AV_CODEC_ID_CAVS

Definition: codec_id.h:139

AV_CODEC_ID_HEVC

@ AV_CODEC_ID_HEVC

Definition: codec_id.h:226

#define xf(width, name, var, range_min, range_max, subs,...)

Definition: cbs_av1.c:598

ff_get_line

int ff_get_line(AVIOContext *s, char *buf, int maxlen)

Read a whole line of text from AVIOContext.

Definition: aviobuf.c:768

AV_CODEC_ID_VC1

@ AV_CODEC_ID_VC1

Definition: codec_id.h:122

demux.h

len

int len

Definition: vorbis_enc_data.h:426

av_get_packet

int av_get_packet(AVIOContext *s, AVPacket *pkt, int size)

Allocate and read the payload of a packet and initialize its fields with default values.

Definition: utils.c:103

AVStream::id

int id

Format-specific stream ID.

Definition: avformat.h:755

ret

Definition: filter_design.txt:187

AVStream

Stream structure.

Definition: avformat.h:743

avio_seek

int64_t avio_seek(AVIOContext *s, int64_t offset, int whence)

fseek() equivalent for AVIOContext.

Definition: aviobuf.c:230

AVClass::class_name

const char * class_name

The name of the class; usually it is the same name as the context structure type to which the AVClass...

Definition: log.h:71

avio_rb16

unsigned int avio_rb16(AVIOContext *s)

Definition: aviobuf.c:745

pos

unsigned int pos

Definition: spdifenc.c:413

avformat.h

av_bprintf

void av_bprintf(AVBPrint *buf, const char *fmt,...)

Definition: bprint.c:99

AV_INPUT_BUFFER_PADDING_SIZE

#define AV_INPUT_BUFFER_PADDING_SIZE

Definition: defs.h:40

mpegps_psm_parse

static long mpegps_psm_parse(MpegDemuxContext *m, AVIOContext *pb)

Extract stream types from a program stream map According to ISO/IEC 13818-1 ('MPEG-2 Systems') table ...

Definition: mpeg.c:201

VIDEO_ID

#define VIDEO_ID

Definition: mpeg.h:42

AVStream::index

int index

stream index in AVFormatContext

Definition: avformat.h:749

STREAM_TYPE_VIDEO_H264

#define STREAM_TYPE_VIDEO_H264

Definition: mpeg.h:57

subtitles.h

channel_layout.h

PADDING_STREAM

#define PADDING_STREAM

Definition: mpeg.h:38

AVIO_SEEKABLE_NORMAL

#define AVIO_SEEKABLE_NORMAL

Seeking works like for a local file.

Definition: avio.h:41

buffer

the frame and frame reference mechanism is intended to as much as expensive copies of that data while still allowing the filters to produce correct results The data is stored in buffers represented by AVFrame structures Several references can point to the same frame buffer

Definition: filter_design.txt:49

AVRational::den

int den

Denominator.

Definition: rational.h:60

avio_read

int avio_read(AVIOContext *s, unsigned char *buf, int size)

Read size bytes from AVIOContext into buf.

Definition: aviobuf.c:611

av_find_input_format

const AVInputFormat * av_find_input_format(const char *short_name)

Find AVInputFormat based on the short name of the input format.

Definition: format.c:145

AVPacket::stream_index

int stream_index

Definition: packet.h:524

avio_skip

int64_t avio_skip(AVIOContext *s, int64_t offset)

Skip given number of bytes forward.

Definition: aviobuf.c:317

av_strdup

char * av_strdup(const char *s)

Duplicate a string.

Definition: mem.c:270

AV_OPT_FLAG_DECODING_PARAM

#define AV_OPT_FLAG_DECODING_PARAM

A generic parameter which can be set by the user for demuxing or decoding.

Definition: opt.h:273

AVMEDIA_TYPE_VIDEO

@ AVMEDIA_TYPE_VIDEO

Definition: avutil.h:201

read_probe

static int read_probe(const AVProbeData *p)

Definition: cdg.c:30

AVFMT_TS_DISCONT

#define AVFMT_TS_DISCONT

Format allows timestamp discontinuities.

Definition: avformat.h:481

AV_CHANNEL_LAYOUT_MONO

#define AV_CHANNEL_LAYOUT_MONO

Definition: channel_layout.h:378

FFStream::request_probe

int request_probe

stream probing state -1 -> probing finished 0 -> no probing requested rest -> perform probing with re...

Definition: internal.h:263

av_free

#define av_free(p)

Definition: tableprint_vlc.h:33

AVCodecParameters::codec_id

enum AVCodecID codec_id

Specific type of the encoded data (the codec used).

Definition: codec_par.h:55

AVPacket

This structure stores compressed data.

Definition: packet.h:499

mpegps_read_pes_header

static int mpegps_read_pes_header(AVFormatContext *s, int64_t *ppos, int *pstart_code, int64_t *ppts, int64_t *pdts)

Definition: mpeg.c:235

av_dict_set

int av_dict_set(AVDictionary **pm, const char *key, const char *value, int flags)

Set the given entry in *pm, overwriting an existing entry.

Definition: dict.c:88

AVPacket::pos

int64_t pos

byte position in stream, -1 if unknown

Definition: packet.h:542

mpegps_probe

static int mpegps_probe(const AVProbeData *p)

Definition: mpeg.c:63

FFInputFormat

Definition: demux.h:37

int32_t

Definition: audioconvert.c:56

AVSTREAM_PARSE_FULL

@ AVSTREAM_PARSE_FULL

full parsing and repack

Definition: avformat.h:593

flags

#define flags(name, subs,...)

Definition: cbs_av1.c:482

av_strlcpy

size_t av_strlcpy(char *dst, const char *src, size_t size)

Copy the string src to dst, but no more than size - 1 bytes, and null-terminate dst.

Definition: avstring.c:85

av_log

#define av_log(a,...)

Definition: tableprint_vlc.h:27

AVERROR_INVALIDDATA

#define AVERROR_INVALIDDATA

Invalid data found when processing input.

Definition: error.h:61

mpegps_read_dts

static int64_t mpegps_read_dts(AVFormatContext *s, int stream_index, int64_t *ppos, int64_t pos_limit)

Definition: mpeg.c:668

read_timestamp

static int64_t read_timestamp(AVFormatContext *s, int stream_index, int64_t *ppos, int64_t pos_limit, int64_t(*read_timestamp)(struct AVFormatContext *, int, int64_t *, int64_t))

Definition: seek.c:279

MAX_SYNC_SIZE

#define MAX_SYNC_SIZE

Definition: mpeg.c:34

AV_OPT_TYPE_STRING

@ AV_OPT_TYPE_STRING

Definition: opt.h:239

ff_reduce_index

void ff_reduce_index(AVFormatContext *s, int stream_index)

Ensure the index uses less memory than the maximum specified in AVFormatContext.max_index_size by dis...

Definition: seek.c:48

MpegDemuxContext