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 "libavutil/channel_layout.h"

23 #include "avformat.h"

24 #include "avio_internal.h"

25 #include "internal.h"

26 #include "mpeg.h"

28 /*********************************************/

29 /* demux code */

31 #define MAX_SYNC_SIZE 100000

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

34 {

35 int pes1;

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

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

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

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

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

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

43 p += 2;

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

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

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

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

49 else

50 pes1 = *p == 0x0F;

52 return pes1 || pes2;

53 }

55 static int check_pack_header(const uint8_t *buf)

56 {

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

58 }

60 static int mpegps_probe(const AVProbeData *p)

61 {

62 uint32_t code = -1;

63 int i;

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

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

66 int endpes = 0;

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

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

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

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

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

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

75 if (code == SYSTEM_HEADER_START_CODE)

76 sys++;

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

78 pspack++;

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

80 endpes = i + len;

81 vid++;

82 }

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

84 // and audio streams

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

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

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

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

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

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

92 }

93 }

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

96 score = AVPROBE_SCORE_EXTENSION / 2;

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

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

100

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

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

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

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

105 return pspack > 2 ? AVPROBE_SCORE_EXTENSION + 2

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

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

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

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

110 : AVPROBE_SCORE_EXTENSION / 2;

111

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

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

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

115 return score;

116 }

117

118 typedef struct MpegDemuxContext {

119 int32_t header_state;

120 unsigned char psm_es_type[256];

121 int sofdec;

122 int dvd;

123 int imkh_cctv;

124 int raw_ac3;

125 } MpegDemuxContext;

126

127 static int mpegps_read_header(AVFormatContext *s)

128 {

129 MpegDemuxContext *m = s->priv_data;

130 char buffer[7] = { 0 };

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

132

133 m->header_state = 0xff;

134 s->ctx_flags |= AVFMTCTX_NOHEADER;

135

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

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

138 m->imkh_cctv = 1;

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

140 m->sofdec = 1;

141 } else

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

143

144 /* no need to do more */

145 return 0;

146 }

147

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

149 {

150 uint8_t buf[5];

151 int ret;

152

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

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

155 if (ret < 4)

156 return AV_NOPTS_VALUE;

157

158 return ff_parse_pes_pts(buf);

159 }

160

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

162 int32_t *header_state)

163 {

164 unsigned int state, v;

165 int val, n;

166

167 state = *header_state;

168 n = *size_ptr;

169 while (n > 0) {

170 if (avio_feof(pb))

171 break;

172 v = avio_r8(pb);

173 n--;

174 if (state == 0x000001) {

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

176 val = state;

177 goto found;

178 }

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

180 }

181 val = -1;

182

183 found:

184 *header_state = state;

185 *size_ptr = n;

186 return val;

187 }

188

189 /**

190 * Extract stream types from a program stream map

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

192 *

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

194 */

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

196 {

197 int psm_length, ps_info_length, es_map_length;

198

199 psm_length = avio_rb16(pb);

200 avio_r8(pb);

201 avio_r8(pb);

202 ps_info_length = avio_rb16(pb);

203

204 /* skip program_stream_info */

205 avio_skip(pb, ps_info_length);

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

207 /* Ignore es_map_length, trust psm_length */

208 es_map_length = psm_length - ps_info_length - 10;

209

210 /* at least one es available? */

211 while (es_map_length >= 4) {

212 unsigned char type = avio_r8(pb);

213 unsigned char es_id = avio_r8(pb);

214 uint16_t es_info_length = avio_rb16(pb);

215

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

217 m->psm_es_type[es_id] = type;

218 /* skip program_stream_info */

219 avio_skip(pb, es_info_length);

220 es_map_length -= 4 + es_info_length;

221 }

222 avio_rb32(pb); /* crc32 */

223 return 2 + psm_length;

224 }

225

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

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

228 */

229 static int mpegps_read_pes_header(AVFormatContext *s,

230 int64_t *ppos, int *pstart_code,

231 int64_t *ppts, int64_t *pdts)

232 {

233 MpegDemuxContext *m = s->priv_data;

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

235 int pes_ext, ext2_len, id_ext, skip;

236 int64_t pts, dts;

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

238

239 error_redo:

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

241 redo:

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

243 m->header_state = 0xff;

244 size = MAX_SYNC_SIZE;

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

246 last_sync = avio_tell(s->pb);

247 if (startcode < 0) {

248 if (avio_feof(s->pb))

249 return AVERROR_EOF;

250 // FIXME we should remember header_state

251 return FFERROR_REDO;

252 }

253

254 if (startcode == PACK_START_CODE)

255 goto redo;

256 if (startcode == SYSTEM_HEADER_START_CODE)

257 goto redo;

258 if (startcode == PADDING_STREAM) {

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

260 goto redo;

261 }

262 if (startcode == PRIVATE_STREAM_2) {

263 if (!m->sofdec) {

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

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

266 int bytesread = 0;

267 uint8_t *ps2buf = av_malloc(len);

268

269 if (ps2buf) {

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

271

272 if (bytesread != len) {

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

274 } else {

275 uint8_t *p = 0;

276 if (len >= 6)

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

278

279 if (p)

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

281

282 m->sofdec -= !m->sofdec;

283

284 if (m->sofdec < 0) {

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

286 /* PCI structure? */

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

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

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

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

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

292

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

294 mins <= 59 &&

295 secs <= 59 &&

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

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

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

299 endpts >= startpts);

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

301 /* DSI structure? */

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

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

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

305

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

307 mins <= 59 &&

308 secs <= 59 &&

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

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

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

312 }

313 }

314 }

315

316 av_free(ps2buf);

317

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

319 * could be allocated, just ignore it.

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

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

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

323 /* Skip back failed.

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

325 * if we can't skip back

326 */

327 goto redo;

328 }

329 } else {

330 /* No memory */

331 avio_skip(s->pb, len);

332 goto redo;

333 }

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

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

336 avio_skip(s->pb, len);

337 goto redo;

338 }

339 }

340 if (startcode == PROGRAM_STREAM_MAP) {

341 mpegps_psm_parse(m, s->pb);

342 goto redo;

343 }

344

345 /* find matching stream */

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

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

348 (startcode == 0x1bd) ||

349 (startcode == PRIVATE_STREAM_2) ||

350 (startcode == 0x1fd)))

351 goto redo;

352 if (ppos) {

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

354 }

355 len = avio_rb16(s->pb);

356 pts =

357 dts = AV_NOPTS_VALUE;

358 if (startcode != PRIVATE_STREAM_2)

359 {

360 /* stuffing */

361 for (;;) {

362 if (len < 1)

363 goto error_redo;

364 c = avio_r8(s->pb);

365 len--;

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

367 if (c != 0xff)

368 break;

369 }

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

371 /* buffer scale & size */

372 avio_r8(s->pb);

373 c = avio_r8(s->pb);

374 len -= 2;

375 }

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

377 dts =

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

379 len -= 4;

380 if (c & 0x10) {

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

382 len -= 5;

383 }

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

385 /* mpeg 2 PES */

386 flags = avio_r8(s->pb);

387 header_len = avio_r8(s->pb);

388 len -= 2;

389 if (header_len > len)

390 goto error_redo;

391 len -= header_len;

392 if (flags & 0x80) {

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

394 header_len -= 5;

395 if (flags & 0x40) {

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

397 header_len -= 5;

398 }

399 }

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

401 flags &= 0xC0;

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

403 }

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

405 pes_ext = avio_r8(s->pb);

406 header_len--;

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

408 * and P-STD buffer */

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

410 skip += skip & 0x9;

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

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

413 pes_ext = skip = 0;

414 }

415 avio_skip(s->pb, skip);

416 header_len -= skip;

417

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

419 ext2_len = avio_r8(s->pb);

420 header_len--;

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

422 id_ext = avio_r8(s->pb);

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

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

425 header_len--;

426 }

427 }

428 }

429 if (header_len < 0)

430 goto error_redo;

431 avio_skip(s->pb, header_len);

432 } else if (c != 0xf)

433 goto redo;

434 }

435

436 if (startcode == PRIVATE_STREAM_1) {

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

438

439 if (ret < 0)

440 return ret;

441

442 startcode = avio_r8(s->pb);

443 m->raw_ac3 = 0;

444 if (startcode == 0x0b) {

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

446 startcode = 0x80;

447 m->raw_ac3 = 1;

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

449 } else {

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

451 }

452 } else {

453 len--;

454 }

455 }

456 if (len < 0)

457 goto error_redo;

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

459 int i;

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

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

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

463 ff_reduce_index(s, i);

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

465 AVINDEX_KEYFRAME /* FIXME keyframe? */);

466 }

467 }

468 }

469

470 *pstart_code = startcode;

471 *ppts = pts;

472 *pdts = dts;

473 return len;

474 }

475

476 static int mpegps_read_packet(AVFormatContext *s,

477 AVPacket *pkt)

478 {

479 MpegDemuxContext *m = s->priv_data;

480 AVStream *st;

481 FFStream *sti;

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

483 int pcm_dvd = 0;

484 int request_probe= 0;

485 enum AVCodecID codec_id = AV_CODEC_ID_NONE;

486 enum AVMediaType type;

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

488

489 redo:

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

491 if (len < 0)

492 return len;

493

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

495 if (len < 4)

496 goto skip;

497

498 if (!m->raw_ac3) {

499 /* audio: skip header */

500 avio_skip(s->pb, 3);

501 len -= 3;

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

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

504 avio_r8(s->pb);

505 len--;

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

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

508 if (ret < 0)

509 return ret;

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

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

512 }

513 }

514 }

515

516 /* now find stream */

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

518 st = s->streams[i];

519 if (st->id == startcode)

520 goto found;

521 }

522

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

524 if (es_type == STREAM_TYPE_VIDEO_MPEG1) {

525 codec_id = AV_CODEC_ID_MPEG2VIDEO;

526 type = AVMEDIA_TYPE_VIDEO;

527 } else if (es_type == STREAM_TYPE_VIDEO_MPEG2) {

528 codec_id = AV_CODEC_ID_MPEG2VIDEO;

529 type = AVMEDIA_TYPE_VIDEO;

530 } else if (es_type == STREAM_TYPE_AUDIO_MPEG1 ||

531 es_type == STREAM_TYPE_AUDIO_MPEG2) {

532 codec_id = AV_CODEC_ID_MP3;

533 type = AVMEDIA_TYPE_AUDIO;

534 } else if (es_type == STREAM_TYPE_AUDIO_AAC) {

535 codec_id = AV_CODEC_ID_AAC;

536 type = AVMEDIA_TYPE_AUDIO;

537 } else if (es_type == STREAM_TYPE_VIDEO_MPEG4) {

538 codec_id = AV_CODEC_ID_MPEG4;

539 type = AVMEDIA_TYPE_VIDEO;

540 } else if (es_type == STREAM_TYPE_VIDEO_H264) {

541 codec_id = AV_CODEC_ID_H264;

542 type = AVMEDIA_TYPE_VIDEO;

543 } else if (es_type == STREAM_TYPE_VIDEO_HEVC) {

544 codec_id = AV_CODEC_ID_HEVC;

545 type = AVMEDIA_TYPE_VIDEO;

546 } else if (es_type == STREAM_TYPE_AUDIO_AC3) {

547 codec_id = AV_CODEC_ID_AC3;

548 type = AVMEDIA_TYPE_AUDIO;

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

550 codec_id = AV_CODEC_ID_PCM_MULAW;

551 type = AVMEDIA_TYPE_AUDIO;

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

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

554 unsigned char buf[8];

555

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

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

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

559 codec_id = AV_CODEC_ID_CAVS;

560 else

561 request_probe= 1;

562 type = AVMEDIA_TYPE_VIDEO;

563 } else if (startcode == PRIVATE_STREAM_2) {

564 type = AVMEDIA_TYPE_DATA;

565 codec_id = AV_CODEC_ID_DVD_NAV;

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

567 type = AVMEDIA_TYPE_AUDIO;

568 if (m->sofdec > 0) {

569 codec_id = AV_CODEC_ID_ADPCM_ADX;

570 // Auto-detect AC-3

571 request_probe = 50;

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

573 codec_id = AV_CODEC_ID_PCM_ALAW;

574 request_probe = 50;

575 } else {

576 codec_id = AV_CODEC_ID_MP2;

577 if (m->imkh_cctv)

578 request_probe = 25;

579 }

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

581 type = AVMEDIA_TYPE_AUDIO;

582 codec_id = AV_CODEC_ID_AC3;

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

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

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

586 type = AVMEDIA_TYPE_AUDIO;

587 codec_id = AV_CODEC_ID_DTS;

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

589 type = AVMEDIA_TYPE_AUDIO;

590 if (!pcm_dvd) {

591 codec_id = AV_CODEC_ID_MLP;

592 } else {

593 codec_id = AV_CODEC_ID_PCM_DVD;

594 }

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

596 type = AVMEDIA_TYPE_AUDIO;

597 codec_id = AV_CODEC_ID_TRUEHD;

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

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

600 type = AVMEDIA_TYPE_AUDIO;

601 codec_id = AV_CODEC_ID_AC3;

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

603 type = AVMEDIA_TYPE_SUBTITLE;

604 codec_id = AV_CODEC_ID_DVD_SUBTITLE;

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

606 type = AVMEDIA_TYPE_VIDEO;

607 codec_id = AV_CODEC_ID_VC1;

608 } else {

609 skip:

610 /* skip packet */

611 avio_skip(s->pb, len);

612 goto redo;

613 }

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

615 st = avformat_new_stream(s, NULL);

616 if (!st)

617 goto skip;

618 sti = ffstream(st);

619 st->id = startcode;

620 st->codecpar->codec_type = type;

621 st->codecpar->codec_id = codec_id;

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

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

624 st->codecpar->channels = 1;

625 st->codecpar->channel_layout = AV_CH_LAYOUT_MONO;

626 st->codecpar->sample_rate = 8000;

627 }

628 sti->request_probe = request_probe;

629 sti->need_parsing = AVSTREAM_PARSE_FULL;

630

631 found:

632 if (st->discard >= AVDISCARD_ALL)

633 goto skip;

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

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

636 if (len < 6)

637 goto skip;

638 avio_skip(s->pb, 6);

639 len -=6;

640 }

641 }

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

643

644 pkt->pts = pts;

645 pkt->dts = dts;

646 pkt->pos = dummy_pos;

647 pkt->stream_index = st->index;

648

649 if (s->debug & FF_FDEBUG_TS)

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

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

652 pkt->size);

653

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

655 }

656

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

658 int64_t *ppos, int64_t pos_limit)

659 {

660 int len, startcode;

661 int64_t pos, pts, dts;

662

663 pos = *ppos;

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

665 return AV_NOPTS_VALUE;

666

667 for (;;) {

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

669 if (len < 0) {

670 if (s->debug & FF_FDEBUG_TS)

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

672 return AV_NOPTS_VALUE;

673 }

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

675 dts != AV_NOPTS_VALUE) {

676 break;

677 }

678 avio_skip(s->pb, len);

679 }

680 if (s->debug & FF_FDEBUG_TS)

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

682 pos, dts, dts / 90000.0);

683 *ppos = pos;

684 return dts;

685 }

686

687 const AVInputFormat ff_mpegps_demuxer = {

688 .name = "mpeg",

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

690 .priv_data_size = sizeof(MpegDemuxContext),

691 .read_probe = mpegps_probe,

692 .read_header = mpegps_read_header,

693 .read_packet = mpegps_read_packet,

694 .read_timestamp = mpegps_read_dts,

695 .flags = AVFMT_SHOW_IDS | AVFMT_TS_DISCONT,

696 };

697

698 #if CONFIG_VOBSUB_DEMUXER

699

700 #include "subtitles.h"

701 #include "libavutil/avassert.h"

702 #include "libavutil/bprint.h"

703 #include "libavutil/opt.h"

704

705 #define REF_STRING "# VobSub index file,"

706 #define MAX_LINE_SIZE 2048

707

708 typedef struct VobSubDemuxContext {

709 const AVClass *class;

710 AVFormatContext *sub_ctx;

711 FFDemuxSubtitlesQueue q[32];

712 char *sub_name;

713 } VobSubDemuxContext;

714

715 static int vobsub_probe(const AVProbeData *p)

716 {

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

718 return AVPROBE_SCORE_MAX;

719 return 0;

720 }

721

722 static int vobsub_read_close(AVFormatContext *s)

723 {

724 VobSubDemuxContext *vobsub = s->priv_data;

725 int i;

726

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

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

729 avformat_close_input(&vobsub->sub_ctx);

730 return 0;

731 }

732

733 static int vobsub_read_header(AVFormatContext *s)

734 {

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

736 VobSubDemuxContext *vobsub = s->priv_data;

737 const AVInputFormat *iformat;

738 size_t fname_len;

739 AVBPrint header;

740 int64_t delay = 0;

741 AVStream *st = NULL;

742 int stream_id = -1;

743 char id[64] = {0};

744 char alt[MAX_LINE_SIZE] = {0};

745

746 if (!vobsub->sub_name) {

747 char *ext;

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

749 if (!vobsub->sub_name) {

750 return AVERROR(ENOMEM);

751 }

752

753 fname_len = strlen(vobsub->sub_name);

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

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

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

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

758 return AVERROR_INVALIDDATA;

759 }

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

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

762 }

763

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

765 return AVERROR_DEMUXER_NOT_FOUND;

766 }

767

768 vobsub->sub_ctx = avformat_alloc_context();

769 if (!vobsub->sub_ctx) {

770 return AVERROR(ENOMEM);

771 }

772

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

774 return ret;

775

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

777 if (ret < 0) {

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

779 return ret;

780 }

781

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

783

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

785 char line[MAX_LINE_SIZE];

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

787

788 if (!len)

789 break;

790

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

792

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

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

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

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

797 strcpy(id, "und");

798 stream_id = 0;

799 }

800

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

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

803 ret = AVERROR(EINVAL);

804 goto end;

805 }

806

807 header_parsed = 1;

808 alt[0] = '0円';

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

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

811

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

813

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

815 AVPacket *sub;

816 int hh, mm, ss, ms;

817 int64_t pos, timestamp;

818 const char *p = line + 10;

819

820 if (stream_id == -1) {

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

822 ret = AVERROR_INVALIDDATA;

823 goto end;

824 }

825

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

827 st = avformat_new_stream(s, NULL);

828 if (!st) {

829 ret = AVERROR(ENOMEM);

830 goto end;

831 }

832 st->id = stream_id;

833 st->codecpar->codec_type = AVMEDIA_TYPE_SUBTITLE;

834 st->codecpar->codec_id = AV_CODEC_ID_DVD_SUBTITLE;

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

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

837 if (alt[0])

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

839 }

840

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

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

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

844 "abort parsing\n", line);

845 ret = AVERROR_INVALIDDATA;

846 goto end;

847 }

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

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

850

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

852 if (!sub) {

853 ret = AVERROR(ENOMEM);

854 goto end;

855 }

856 sub->pos = pos;

857 sub->pts = timestamp;

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

859

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

861 const char *p = line + 4;

862

863 while (*p == ' ')

864 p++;

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

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

867 header_parsed = 1;

868

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

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

871 const char *p = line + 6;

872

873 while (*p == ' ')

874 p++;

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

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

877 p++;

878 }

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

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

881

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

883 const char *p = line + 8;

884

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

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

887

888 } else if (!header_parsed) {

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

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

891 }

892 }

893

894 if (langidx < s->nb_streams)

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

896

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

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

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

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

901 }

902

903 if (!av_bprint_is_complete(&header)) {

904 ret = AVERROR(ENOMEM);

905 goto end;

906 }

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

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

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

910 if (ret < 0) {

911 goto end;

912 }

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

914 }

915 end:

916 av_bprint_finalize(&header, NULL);

917 return ret;

918 }

919

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

921 {

922 VobSubDemuxContext *vobsub = s->priv_data;

923 FFDemuxSubtitlesQueue *q;

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

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

926

927 int64_t min_ts = INT64_MAX;

928 int sid = 0;

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

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

931 int64_t ts;

932 av_assert0(tmpq->nb_subs);

933

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

935 continue;

936

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

938 if (ts < min_ts) {

939 min_ts = ts;

940 sid = i;

941 }

942 }

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

944 /* The returned packet will have size zero,

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

946 ret = ff_subtitles_queue_read_packet(q, pkt);

947 if (ret < 0)

948 return ret;

949

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

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

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

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

954 } else {

955 int64_t fsize = avio_size(pb);

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

957 }

958

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

960

961 do {

962 int n, to_read, startcode;

963 int64_t pts, dts;

964 int64_t old_pos = avio_tell(pb), new_pos;

965 int pkt_size;

966

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

968 if (ret < 0) {

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

970 break;

971 return ret;

972 }

973 to_read = ret & 0xffff;

974 new_pos = avio_tell(pb);

975 pkt_size = ret + (new_pos - old_pos);

976

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

978 if (total_read + pkt_size > psize)

979 break;

980 total_read += pkt_size;

981

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

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

984 break;

985

986 ret = av_grow_packet(pkt, to_read);

987 if (ret < 0)

988 return ret;

989

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

991 if (n < to_read)

992 pkt->size -= to_read - n;

993 } while (total_read < psize);

994

995 return 0;

996 }

997

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

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

1000 {

1001 VobSubDemuxContext *vobsub = s->priv_data;

1002

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

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

1005 * like in avformat_seek_file(). */

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

1007 int i, ret = 0;

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

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

1010 min_ts = av_rescale_rnd(min_ts, time_base.den,

1011 time_base.num * (int64_t)AV_TIME_BASE,

1012 AV_ROUND_UP | AV_ROUND_PASS_MINMAX);

1013 max_ts = av_rescale_rnd(max_ts, time_base.den,

1014 time_base.num * (int64_t)AV_TIME_BASE,

1015 AV_ROUND_DOWN | AV_ROUND_PASS_MINMAX);

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

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

1018 min_ts, ts, max_ts, flags);

1019 if (r < 0)

1020 ret = r;

1021 }

1022 return ret;

1023 }

1024

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

1026 stream_index = 0;

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

1028 min_ts, ts, max_ts, flags);

1029 }

1030

1031 static const AVOption options[] = {

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

1033 { NULL }

1034 };

1035

1036 static const AVClass vobsub_demuxer_class = {

1037 .class_name = "vobsub",

1038 .item_name = av_default_item_name,

1039 .option = options,

1040 .version = LIBAVUTIL_VERSION_INT,

1041 };

1042

1043 const AVInputFormat ff_vobsub_demuxer = {

1044 .name = "vobsub",

1045 .long_name = NULL_IF_CONFIG_SMALL("VobSub subtitle format"),

1046 .priv_data_size = sizeof(VobSubDemuxContext),

1047 .flags_internal = FF_FMT_INIT_CLEANUP,

1048 .read_probe = vobsub_probe,

1049 .read_header = vobsub_read_header,

1050 .read_packet = vobsub_read_packet,

1051 .read_seek2 = vobsub_read_seek,

1052 .read_close = vobsub_read_close,

1053 .flags = AVFMT_SHOW_IDS,

1054 .extensions = "idx",

1055 .priv_class = &vobsub_demuxer_class,

1056 };

1057 #endif

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:74

AV_CODEC_ID_AC3

@ AV_CODEC_ID_AC3

Definition: codec_id.h:426

SYSTEM_HEADER_START_CODE

#define SYSTEM_HEADER_START_CODE

Definition: mpeg.h:29

FF_FMT_INIT_CLEANUP

#define FF_FMT_INIT_CLEANUP

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

Definition: internal.h:49

ff_mpegps_demuxer

const AVInputFormat ff_mpegps_demuxer

Definition: mpeg.c:687

mpegps_read_packet

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

Definition: mpeg.c:476

const char * r

Definition: vf_curves.c:116

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

avformat_new_stream

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

Add a new stream to a media file.

Definition: utils.c:768

AVCodecParameters::codec_type

enum AVMediaType codec_type

General type of the encoded data.

Definition: codec_par.h:56

AVFMT_SHOW_IDS

#define AVFMT_SHOW_IDS

Show format stream IDs numbers.

Definition: avformat.h:473

av_bprint_finalize

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

Finalize a print buffer.

Definition: bprint.c:234

FF_FDEBUG_TS

#define FF_FDEBUG_TS

Definition: avformat.h:1473

FFERROR_REDO

#define FFERROR_REDO

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

Definition: internal.h:912

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:68

av_bprint_init

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

Definition: bprint.c:68

AVCodecParameters

This struct describes the properties of an encoded stream.

Definition: codec_par.h:52

sub

static float sub(float src0, float src1)

Definition: dnn_backend_native_layer_mathbinary.c:31

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:997

AV_CH_LAYOUT_MONO

#define AV_CH_LAYOUT_MONO

Definition: channel_layout.h:90

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:260

av_grow_packet

int av_grow_packet(AVPacket *pkt, int grow_by)

Increase packet size, correctly zeroing padding.

Definition: avpacket.c:122

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:820

AV_CODEC_ID_MPEG4

@ AV_CODEC_ID_MPEG4

Definition: codec_id.h:62

STREAM_TYPE_AUDIO_MPEG1

#define STREAM_TYPE_AUDIO_MPEG1

Definition: mpeg.h:51

AVPacket::data

uint8_t * data

Definition: packet.h:373

AVOption

AVOption.

Definition: opt.h:247

find_next_start_code

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

Definition: mpeg.c:161

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:450

avio_size

int64_t avio_size(AVIOContext *s)

Get the filesize.

Definition: aviobuf.c:352

AV_CODEC_ID_TRUEHD

@ AV_CODEC_ID_TRUEHD

Definition: codec_id.h:467

MpegDemuxContext::dvd

int dvd

Definition: mpeg.c:122

av_malloc

#define av_malloc(s)

Definition: tableprint_vlc.h:31

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:809

AVPROBE_SCORE_MAX

#define AVPROBE_SCORE_MAX

maximum score

Definition: avformat.h:459

avformat_close_input

void avformat_close_input(AVFormatContext **s)

Close an opened input AVFormatContext.

Definition: demux.c:355

AVCodecParameters::channels

int channels

Audio only.

Definition: codec_par.h:166

ffstream

static av_always_inline FFStream * ffstream(AVStream *st)

Definition: internal.h:432

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:117

read_close

static av_cold int read_close(AVFormatContext *ctx)

Definition: libcdio.c:141

avio_tell

static av_always_inline int64_t avio_tell(AVIOContext *s)

ftell() equivalent for AVIOContext.

Definition: avio.h:504

val

static double val(void *priv, double ch)

Definition: aeval.c:76

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:653

AV_ROUND_UP

@ AV_ROUND_UP

Round toward +infinity.

Definition: mathematics.h:83

AV_CODEC_ID_MP3

@ AV_CODEC_ID_MP3

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

Definition: codec_id.h:424

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

Definition: cbs_vp9.c:261

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:253

avassert.h

avio_rb32

unsigned int avio_rb32(AVIOContext *s)

Definition: aviobuf.c:790

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:650

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:207

STREAM_TYPE_AUDIO_AC3

#define STREAM_TYPE_AUDIO_AC3

Definition: mpeg.h:61

STREAM_TYPE_VIDEO_MPEG4

#define STREAM_TYPE_VIDEO_MPEG4

Definition: mpeg.h:56

#define s(width, name)

Definition: cbs_vp9.c:257

AVInputFormat::name

const char * name

A comma separated list of short names for the format.

Definition: avformat.h:655

AVProbeData::buf

unsigned char * buf

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

Definition: avformat.h:449

AVMEDIA_TYPE_AUDIO

@ AVMEDIA_TYPE_AUDIO

Definition: avutil.h:202

AV_CODEC_ID_MP2

@ AV_CODEC_ID_MP2

Definition: codec_id.h:423

get_pts

static int64_t get_pts(AVIOContext *pb, int c)

Definition: mpeg.c:148

av_assert0

#define av_assert0(cond)

assert() equivalent, that is always enabled.

Definition: avassert.h:37

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:297

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:141

AV_CODEC_ID_PCM_MULAW

@ AV_CODEC_ID_PCM_MULAW

Definition: codec_id.h:320

codec_id

enum AVCodecID codec_id

Definition: vaapi_decode.c:369

AV_CODEC_ID_PCM_DVD

@ AV_CODEC_ID_PCM_DVD

Definition: codec_id.h:333

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:214

AV_CODEC_ID_H264

@ AV_CODEC_ID_H264

Definition: codec_id.h:77

AV_CODEC_ID_DVD_NAV

@ AV_CODEC_ID_DVD_NAV

Definition: codec_id.h:560

if(ret)

Definition: filter_design.txt:179

AVERROR_DEMUXER_NOT_FOUND

#define AVERROR_DEMUXER_NOT_FOUND

Demuxer not found.

Definition: error.h:55

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:405

AVDISCARD_ALL

@ AVDISCARD_ALL

discard all

Definition: defs.h:54

AVFormatContext

Format I/O context.

Definition: avformat.h:1200

AV_CODEC_ID_PCM_ALAW

@ AV_CODEC_ID_PCM_ALAW

Definition: codec_id.h:321

internal.h

mpegps_read_header

static int mpegps_read_header(AVFormatContext *s)

Definition: mpeg.c:127

AVStream::codecpar

AVCodecParameters * codecpar

Codec parameters associated with this stream.

Definition: avformat.h:1095

LIBAVUTIL_VERSION_INT

#define LIBAVUTIL_VERSION_INT

Definition: version.h:85

read_header

static int read_header(FFV1Context *f)

Definition: ffv1dec.c:527

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:965

NULL

#define NULL

Definition: coverity.c:32

read_probe

static int read_probe(const AVProbeData *pd)

Definition: jvdec.c:55

AVFMTCTX_NOHEADER

#define AVFMTCTX_NOHEADER

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

Definition: avformat.h:1151

check_pes

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

Definition: mpeg.c:33

AVRational

Rational number (pair of numerator and denominator).

Definition: rational.h:58

AV_CODEC_ID_DVD_SUBTITLE

@ AV_CODEC_ID_DVD_SUBTITLE

Definition: codec_id.h:522

av_default_item_name

const char * av_default_item_name(void *ptr)

Return the context name.

Definition: log.c:235

AVProbeData

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

Definition: avformat.h:447

AVStream::metadata

AVDictionary * metadata

Definition: avformat.h:1006

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

MpegDemuxContext::sofdec

int sofdec

Definition: mpeg.c:121

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:457

AVCodecParameters::sample_rate

int sample_rate

Audio only.

Definition: codec_par.h:170

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:185

AVCodecID

Identify the syntax and semantics of the bitstream.

Definition: codec_id.h:47

AV_CODEC_ID_AAC

@ AV_CODEC_ID_AAC

Definition: codec_id.h:425

ff_vobsub_demuxer

const AVInputFormat ff_vobsub_demuxer

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:57

options

const OptionDef options[]

AVIOContext

Bytestream IO Context.

Definition: avio.h:161

avio_rb24

unsigned int avio_rb24(AVIOContext *s)

Definition: aviobuf.c:783

state

static struct @320 state

MpegDemuxContext::psm_es_type

unsigned char psm_es_type[256]

Definition: mpeg.c:120

AVMediaType

Definition: avutil.h:199

AV_CODEC_ID_ADPCM_ADX

@ AV_CODEC_ID_ADPCM_ADX

Definition: codec_id.h:362

AVPacket::size

int size

Definition: packet.h:374

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:117

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:55

avformat_alloc_context

AVFormatContext * avformat_alloc_context(void)

Allocate an AVFormatContext.

Definition: options.c:154

STREAM_TYPE_VIDEO_HEVC

#define STREAM_TYPE_VIDEO_HEVC

Definition: mpeg.h:58

FFStream

Definition: internal.h:194

AV_CODEC_ID_DTS

@ AV_CODEC_ID_DTS

Definition: codec_id.h:427

ff_copy_whiteblacklists

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

Copies the whilelists from one context to the other.

Definition: utils.c:115

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:895

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:119

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:196

FFDemuxSubtitlesQueue

Definition: subtitles.h:103

header

static const uint8_t header[24]

Definition: sdr2.c:67

AVPacket::dts

int64_t dts

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

Definition: packet.h:372

avio_r8

int avio_r8(AVIOContext *s)

Definition: aviobuf.c:632

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:1055

ff_subtitles_queue_clean

void ff_subtitles_queue_clean(FFDemuxSubtitlesQueue *q)

Remove and destroy all the subtitles packets.

Definition: subtitles.c:305

mpeg.h

line

Definition: graph2dot.c:48

MpegDemuxContext::imkh_cctv

int imkh_cctv

Definition: mpeg.c:123

MpegDemuxContext::raw_ac3

int raw_ac3

Definition: mpeg.c:124

iformat

static const AVInputFormat * iformat

Definition: ffprobe.c:274

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:48

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

Definition: cbs_h2645.c:271

AVPacket::pts

int64_t pts

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

Definition: packet.h:366

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:137

AV_ROUND_DOWN

@ AV_ROUND_DOWN

Round toward -infinity.

Definition: mathematics.h:82

AV_CODEC_ID_HEVC

@ AV_CODEC_ID_HEVC

Definition: codec_id.h:224

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

Definition: cbs_av1.c:664

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:278

ff_get_line

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

Read a whole line of text from AVIOContext.

Definition: aviobuf.c:798

AV_CODEC_ID_VC1

@ AV_CODEC_ID_VC1

Definition: codec_id.h:120

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:197

AVStream::id

int id

Format-specific stream ID.

Definition: avformat.h:949

ret

Definition: filter_design.txt:187

read_packet

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

Definition: avio_reading.c:42

AVStream

Stream structure.

Definition: avformat.h:935

avio_seek

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

fseek() equivalent for AVIOContext.

Definition: aviobuf.c:260

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:775

pos

unsigned int pos

Definition: spdifenc.c:412

avformat.h

av_bprintf

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

Definition: bprint.c:93

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:195

VIDEO_ID

#define VIDEO_ID

Definition: mpeg.h:42

AVStream::index

int index

stream index in AVFormatContext

Definition: avformat.h:943

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:40

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

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:45

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:641

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: utils.c:1196

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:118

AVPacket::stream_index

int stream_index

Definition: packet.h:375

avio_skip

int64_t avio_skip(AVIOContext *s, int64_t offset)

Skip given number of bytes forward.

Definition: aviobuf.c:347

av_strdup

char * av_strdup(const char *s)

Duplicate a string.

Definition: mem.c:279

AVMEDIA_TYPE_VIDEO

@ AVMEDIA_TYPE_VIDEO

Definition: avutil.h:201

AVFMT_TS_DISCONT

#define AVFMT_TS_DISCONT

Format allows timestamp discontinuities.

Definition: avformat.h:477

FFStream::request_probe

int request_probe

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

Definition: internal.h:291

av_free

#define av_free(p)

Definition: tableprint_vlc.h:34

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:108

AVCodecParameters::codec_id

enum AVCodecID codec_id

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

Definition: codec_par.h:60

AVPacket

This structure stores compressed data.

Definition: packet.h:350

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:229

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:70

AVPacket::pos

int64_t pos

byte position in stream, -1 if unknown

Definition: packet.h:393

mpegps_probe

static int mpegps_probe(const AVProbeData *p)

Definition: mpeg.c:60

AVCodecParameters::channel_layout

uint64_t channel_layout

Audio only.

Definition: codec_par.h:162

int32_t

Definition: audioconvert.c:56

AVSTREAM_PARSE_FULL

@ AVSTREAM_PARSE_FULL

full parsing and repack

Definition: avformat.h:792

flags

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

Definition: cbs_av1.c:561

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:83

av_log

#define av_log(a,...)

Definition: tableprint_vlc.h:28

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:657

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:273

MAX_SYNC_SIZE

#define MAX_SYNC_SIZE

Definition: mpeg.c:31

AV_OPT_TYPE_STRING

@ AV_OPT_TYPE_STRING

Definition: opt.h:228

MpegDemuxContext

Definition: mpeg.c:118

AV_CODEC_ID_MPEG2VIDEO

@ AV_CODEC_ID_MPEG2VIDEO

preferred ID for MPEG-1/2 video decoding