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 "avformat.h"

23 #include "avio_internal.h"

24 #include "internal.h"

25 #include "mpeg.h"

27 #if CONFIG_VOBSUB_DEMUXER

28 # include "subtitles.h"

29 # include "libavutil/bprint.h"

30 # include "libavutil/opt.h"

31 #endif

33 #include "libavutil/avassert.h"

35 /*********************************************/

36 /* demux code */

38 #define MAX_SYNC_SIZE 100000

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

41 {

42 int pes1;

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

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

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

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

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

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

50 p += 2;

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

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

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

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

56 else

57 pes1 = *p == 0x0F;

59 return pes1 || pes2;

60 }

62 static int check_pack_header(const uint8_t *buf)

63 {

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

65 }

67 static int mpegps_probe(AVProbeData *p)

68 {

69 uint32_t code = -1;

70 int i;

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

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

73 int endpes = 0;

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

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

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

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

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

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

82 if (code == SYSTEM_HEADER_START_CODE)

83 sys++;

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

85 pspack++;

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

87 endpes = i + len;

88 vid++;

89 }

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

91 // and audio streams

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

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

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

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

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

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

99 }

100 }

101

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

103 score = AVPROBE_SCORE_EXTENSION / 2;

104

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

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

107

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

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

110 : AVPROBE_SCORE_EXTENSION / 2 + 1; // 1 more than mp3

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

112 return pspack > 2 ? AVPROBE_SCORE_EXTENSION + 2

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

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

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

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

117 : AVPROBE_SCORE_EXTENSION / 2;

118

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

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

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

122 return score;

123 }

124

125 typedef struct MpegDemuxContext {

126 AVClass *class;

127 int32_t header_state;

128 unsigned char psm_es_type[256];

129 int sofdec;

130 int dvd;

131 int imkh_cctv;

132 int raw_ac3;

133 #if CONFIG_VOBSUB_DEMUXER

134 AVFormatContext *sub_ctx;

135 FFDemuxSubtitlesQueue q[32];

136 char *sub_name;

137 #endif

138 } MpegDemuxContext;

139

140 static int mpegps_read_header(AVFormatContext *s)

141 {

142 MpegDemuxContext *m = s->priv_data;

143 char buffer[7] = { 0 };

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

145

146 m->header_state = 0xff;

147 s->ctx_flags |= AVFMTCTX_NOHEADER;

148

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

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

151 m->imkh_cctv = 1;

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

153 m->sofdec = 1;

154 } else

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

156

157 /* no need to do more */

158 return 0;

159 }

160

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

162 {

163 uint8_t buf[5];

164

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

166 avio_read(pb, buf + 1, 4);

167

168 return ff_parse_pes_pts(buf);

169 }

170

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

172 int32_t *header_state)

173 {

174 unsigned int state, v;

175 int val, n;

176

177 state = *header_state;

178 n = *size_ptr;

179 while (n > 0) {

180 if (avio_feof(pb))

181 break;

182 v = avio_r8(pb);

183 n--;

184 if (state == 0x000001) {

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

186 val = state;

187 goto found;

188 }

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

190 }

191 val = -1;

192

193 found:

194 *header_state = state;

195 *size_ptr = n;

196 return val;

197 }

198

199 /**

200 * Extract stream types from a program stream map

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

202 *

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

204 */

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

206 {

207 int psm_length, ps_info_length, es_map_length;

208

209 psm_length = avio_rb16(pb);

210 avio_r8(pb);

211 avio_r8(pb);

212 ps_info_length = avio_rb16(pb);

213

214 /* skip program_stream_info */

215 avio_skip(pb, ps_info_length);

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

217 /* Ignore es_map_length, trust psm_length */

218 es_map_length = psm_length - ps_info_length - 10;

219

220 /* at least one es available? */

221 while (es_map_length >= 4) {

222 unsigned char type = avio_r8(pb);

223 unsigned char es_id = avio_r8(pb);

224 uint16_t es_info_length = avio_rb16(pb);

225

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

227 m->psm_es_type[es_id] = type;

228 /* skip program_stream_info */

229 avio_skip(pb, es_info_length);

230 es_map_length -= 4 + es_info_length;

231 }

232 avio_rb32(pb); /* crc32 */

233 return 2 + psm_length;

234 }

235

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

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

238 */

239 static int mpegps_read_pes_header(AVFormatContext *s,

240 int64_t *ppos, int *pstart_code,

241 int64_t *ppts, int64_t *pdts)

242 {

243 MpegDemuxContext *m = s->priv_data;

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

245 int pes_ext, ext2_len, id_ext, skip;

246 int64_t pts, dts;

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

248

249 error_redo:

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

251 redo:

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

253 m->header_state = 0xff;

254 size = MAX_SYNC_SIZE;

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

256 last_sync = avio_tell(s->pb);

257 if (startcode < 0) {

258 if (avio_feof(s->pb))

259 return AVERROR_EOF;

260 // FIXME we should remember header_state

261 return FFERROR_REDO;

262 }

263

264 if (startcode == PACK_START_CODE)

265 goto redo;

266 if (startcode == SYSTEM_HEADER_START_CODE)

267 goto redo;

268 if (startcode == PADDING_STREAM) {

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

270 goto redo;

271 }

272 if (startcode == PRIVATE_STREAM_2) {

273 if (!m->sofdec) {

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

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

276 int bytesread = 0;

277 uint8_t *ps2buf = av_malloc(len);

278

279 if (ps2buf) {

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

281

282 if (bytesread != len) {

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

284 } else {

285 uint8_t *p = 0;

286 if (len >= 6)

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

288

289 if (p)

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

291

292 m->sofdec -= !m->sofdec;

293

294 if (m->sofdec < 0) {

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

296 /* PCI structure? */

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

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

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

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

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

302

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

304 mins <= 59 &&

305 secs <= 59 &&

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

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

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

309 endpts >= startpts);

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

311 /* DSI structure? */

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

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

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

315

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

317 mins <= 59 &&

318 secs <= 59 &&

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

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

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

322 }

323 }

324 }

325

326 av_free(ps2buf);

327

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

329 * could be allocated, just ignore it.

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

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

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

333 /* Skip back failed.

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

335 * if we can't skip back

336 */

337 goto redo;

338 }

339 } else {

340 /* No memory */

341 avio_skip(s->pb, len);

342 goto redo;

343 }

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

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

346 avio_skip(s->pb, len);

347 goto redo;

348 }

349 }

350 if (startcode == PROGRAM_STREAM_MAP) {

351 mpegps_psm_parse(m, s->pb);

352 goto redo;

353 }

354

355 /* find matching stream */

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

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

358 (startcode == 0x1bd) ||

359 (startcode == PRIVATE_STREAM_2) ||

360 (startcode == 0x1fd)))

361 goto redo;

362 if (ppos) {

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

364 }

365 len = avio_rb16(s->pb);

366 pts =

367 dts = AV_NOPTS_VALUE;

368 if (startcode != PRIVATE_STREAM_2)

369 {

370 /* stuffing */

371 for (;;) {

372 if (len < 1)

373 goto error_redo;

374 c = avio_r8(s->pb);

375 len--;

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

377 if (c != 0xff)

378 break;

379 }

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

381 /* buffer scale & size */

382 avio_r8(s->pb);

383 c = avio_r8(s->pb);

384 len -= 2;

385 }

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

387 dts =

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

389 len -= 4;

390 if (c & 0x10) {

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

392 len -= 5;

393 }

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

395 /* mpeg 2 PES */

396 flags = avio_r8(s->pb);

397 header_len = avio_r8(s->pb);

398 len -= 2;

399 if (header_len > len)

400 goto error_redo;

401 len -= header_len;

402 if (flags & 0x80) {

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

404 header_len -= 5;

405 if (flags & 0x40) {

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

407 header_len -= 5;

408 }

409 }

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

411 flags &= 0xC0;

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

413 }

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

415 pes_ext = avio_r8(s->pb);

416 header_len--;

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

418 * and P-STD buffer */

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

420 skip += skip & 0x9;

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

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

423 pes_ext = skip = 0;

424 }

425 avio_skip(s->pb, skip);

426 header_len -= skip;

427

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

429 ext2_len = avio_r8(s->pb);

430 header_len--;

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

432 id_ext = avio_r8(s->pb);

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

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

435 header_len--;

436 }

437 }

438 }

439 if (header_len < 0)

440 goto error_redo;

441 avio_skip(s->pb, header_len);

442 } else if (c != 0xf)

443 goto redo;

444 }

445

446 if (startcode == PRIVATE_STREAM_1) {

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

448

449 if (ret < 0)

450 return ret;

451

452 startcode = avio_r8(s->pb);

453 m->raw_ac3 = 0;

454 if (startcode == 0x0b) {

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

456 startcode = 0x80;

457 m->raw_ac3 = 1;

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

459 } else {

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

461 }

462 } else {

463 len--;

464 }

465 }

466 if (len < 0)

467 goto error_redo;

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

469 int i;

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

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

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

473 ff_reduce_index(s, i);

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

475 AVINDEX_KEYFRAME /* FIXME keyframe? */);

476 }

477 }

478 }

479

480 *pstart_code = startcode;

481 *ppts = pts;

482 *pdts = dts;

483 return len;

484 }

485

486 static int mpegps_read_packet(AVFormatContext *s,

487 AVPacket *pkt)

488 {

489 MpegDemuxContext *m = s->priv_data;

490 AVStream *st;

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

492 int lpcm_header_len = -1; //Init to suppress warning

493 int request_probe= 0;

494 enum AVCodecID codec_id = AV_CODEC_ID_NONE;

495 enum AVMediaType type;

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

497

498 redo:

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

500 if (len < 0)

501 return len;

502

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

504 if (len < 4)

505 goto skip;

506

507 if (!m->raw_ac3) {

508 /* audio: skip header */

509 avio_r8(s->pb);

510 lpcm_header_len = avio_rb16(s->pb);

511 len -= 3;

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

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

514 avio_r8(s->pb);

515 len--;

516 }

517 }

518 }

519

520 /* now find stream */

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

522 st = s->streams[i];

523 if (st->id == startcode)

524 goto found;

525 }

526

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

528 if (es_type == STREAM_TYPE_VIDEO_MPEG1) {

529 codec_id = AV_CODEC_ID_MPEG2VIDEO;

530 type = AVMEDIA_TYPE_VIDEO;

531 } else if (es_type == STREAM_TYPE_VIDEO_MPEG2) {

532 codec_id = AV_CODEC_ID_MPEG2VIDEO;

533 type = AVMEDIA_TYPE_VIDEO;

534 } else if (es_type == STREAM_TYPE_AUDIO_MPEG1 ||

535 es_type == STREAM_TYPE_AUDIO_MPEG2) {

536 codec_id = AV_CODEC_ID_MP3;

537 type = AVMEDIA_TYPE_AUDIO;

538 } else if (es_type == STREAM_TYPE_AUDIO_AAC) {

539 codec_id = AV_CODEC_ID_AAC;

540 type = AVMEDIA_TYPE_AUDIO;

541 } else if (es_type == STREAM_TYPE_VIDEO_MPEG4) {

542 codec_id = AV_CODEC_ID_MPEG4;

543 type = AVMEDIA_TYPE_VIDEO;

544 } else if (es_type == STREAM_TYPE_VIDEO_H264) {

545 codec_id = AV_CODEC_ID_H264;

546 type = AVMEDIA_TYPE_VIDEO;

547 } else if (es_type == STREAM_TYPE_AUDIO_AC3) {

548 codec_id = AV_CODEC_ID_AC3;

549 type = AVMEDIA_TYPE_AUDIO;

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

551 codec_id = AV_CODEC_ID_PCM_MULAW;

552 type = AVMEDIA_TYPE_AUDIO;

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

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

555 unsigned char buf[8];

556

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

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

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

560 codec_id = AV_CODEC_ID_CAVS;

561 else

562 request_probe= 1;

563 type = AVMEDIA_TYPE_VIDEO;

564 } else if (startcode == PRIVATE_STREAM_2) {

565 type = AVMEDIA_TYPE_DATA;

566 codec_id = AV_CODEC_ID_DVD_NAV;

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

568 type = AVMEDIA_TYPE_AUDIO;

569 if (m->sofdec > 0) {

570 codec_id = AV_CODEC_ID_ADPCM_ADX;

571 // Auto-detect AC-3

572 request_probe = 50;

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

574 codec_id = AV_CODEC_ID_PCM_ALAW;

575 request_probe = 50;

576 } else {

577 codec_id = AV_CODEC_ID_MP2;

578 if (m->imkh_cctv)

579 request_probe = 25;

580 }

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

582 type = AVMEDIA_TYPE_AUDIO;

583 codec_id = AV_CODEC_ID_AC3;

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

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

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

587 type = AVMEDIA_TYPE_AUDIO;

588 codec_id = AV_CODEC_ID_DTS;

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

590 type = AVMEDIA_TYPE_AUDIO;

591 if (lpcm_header_len >= 6 && startcode == 0xa1) {

592 codec_id = AV_CODEC_ID_MLP;

593 } else {

594 codec_id = AV_CODEC_ID_PCM_DVD;

595 }

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

597 type = AVMEDIA_TYPE_AUDIO;

598 codec_id = AV_CODEC_ID_TRUEHD;

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

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

601 type = AVMEDIA_TYPE_AUDIO;

602 codec_id = AV_CODEC_ID_AC3;

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

604 type = AVMEDIA_TYPE_SUBTITLE;

605 codec_id = AV_CODEC_ID_DVD_SUBTITLE;

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

607 type = AVMEDIA_TYPE_VIDEO;

608 codec_id = AV_CODEC_ID_VC1;

609 } else {

610 skip:

611 /* skip packet */

612 avio_skip(s->pb, len);

613 goto redo;

614 }

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

616 st = avformat_new_stream(s, NULL);

617 if (!st)

618 goto skip;

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 st->request_probe = request_probe;

629 st->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_TRACE, "%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_TRACE, "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_TRACE, "pos=0x%"PRIx64" dts=0x%"PRIx64" %0.3f\n",

682 pos, dts, dts / 90000.0);

683 *ppos = pos;

684 return dts;

685 }

686

687 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 #define REF_STRING "# VobSub index file,"

701 #define MAX_LINE_SIZE 2048

702

703 static int vobsub_probe(AVProbeData *p)

704 {

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

706 return AVPROBE_SCORE_MAX;

707 return 0;

708 }

709

710 static int vobsub_read_header(AVFormatContext *s)

711 {

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

713 MpegDemuxContext *vobsub = s->priv_data;

714 size_t fname_len;

715 char *header_str;

716 AVBPrint header;

717 int64_t delay = 0;

718 AVStream *st = NULL;

719 int stream_id = -1;

720 char id[64] = {0};

721 char alt[MAX_LINE_SIZE] = {0};

722 AVInputFormat *iformat;

723

724 if (!vobsub->sub_name) {

725 char *ext;

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

727 if (!vobsub->sub_name) {

728 ret = AVERROR(ENOMEM);

729 goto end;

730 }

731

732 fname_len = strlen(vobsub->sub_name);

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

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

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

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

737 ret = AVERROR_INVALIDDATA;

738 goto end;

739 }

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

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

742 }

743

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

745 ret = AVERROR_DEMUXER_NOT_FOUND;

746 goto end;

747 }

748

749 vobsub->sub_ctx = avformat_alloc_context();

750 if (!vobsub->sub_ctx) {

751 ret = AVERROR(ENOMEM);

752 goto end;

753 }

754

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

756 goto end;

757

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

759 if (ret < 0) {

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

761 goto end;

762 }

763

764 av_bprint_init(&header, 0, AV_BPRINT_SIZE_UNLIMITED);

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

766 char line[MAX_LINE_SIZE];

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

768

769 if (!len)

770 break;

771

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

773

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

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

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

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

778 strcpy(id, "und");

779 stream_id = 0;

780 }

781

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

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

784 ret = AVERROR(EINVAL);

785 goto end;

786 }

787

788 header_parsed = 1;

789 alt[0] = '0円';

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

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

792

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

794

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

796 AVPacket *sub;

797 int hh, mm, ss, ms;

798 int64_t pos, timestamp;

799 const char *p = line + 10;

800

801 if (stream_id == -1) {

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

803 ret = AVERROR_INVALIDDATA;

804 goto end;

805 }

806

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

808 st = avformat_new_stream(s, NULL);

809 if (!st) {

810 ret = AVERROR(ENOMEM);

811 goto end;

812 }

813 st->id = stream_id;

814 st->codecpar->codec_type = AVMEDIA_TYPE_SUBTITLE;

815 st->codecpar->codec_id = AV_CODEC_ID_DVD_SUBTITLE;

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

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

818 if (alt[0])

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

820 }

821

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

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

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

825 "abort parsing\n", line);

826 ret = AVERROR_INVALIDDATA;

827 goto end;

828 }

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

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

831

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

833 if (!sub) {

834 ret = AVERROR(ENOMEM);

835 goto end;

836 }

837 sub->pos = pos;

838 sub->pts = timestamp;

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

840

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

842 const char *p = line + 4;

843

844 while (*p == ' ')

845 p++;

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

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

848 header_parsed = 1;

849

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

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

852 const char *p = line + 6;

853

854 while (*p == ' ')

855 p++;

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

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

858 p++;

859 }

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

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

862

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

864 const char *p = line + 8;

865

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

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

868

869 } else if (!header_parsed) {

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

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

872 }

873 }

874

875 if (langidx < s->nb_streams)

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

877

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

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

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

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

882 }

883

884 if (!av_bprint_is_complete(&header)) {

885 av_bprint_finalize(&header, NULL);

886 ret = AVERROR(ENOMEM);

887 goto end;

888 }

889 av_bprint_finalize(&header, &header_str);

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

891 AVStream *sub_st = s->streams[i];

892 sub_st->codecpar->extradata = av_strdup(header_str);

893 sub_st->codecpar->extradata_size = header.len;

894 }

895 av_free(header_str);

896

897 end:

898 return ret;

899 }

900

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

902 {

903 MpegDemuxContext *vobsub = s->priv_data;

904 FFDemuxSubtitlesQueue *q;

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

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

907 AVPacket idx_pkt = { 0 };

908

909 int64_t min_ts = INT64_MAX;

910 int sid = 0;

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

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

913 int64_t ts;

914 av_assert0(tmpq->nb_subs);

915 ts = tmpq->subs[tmpq->current_sub_idx].pts;

916 if (ts < min_ts) {

917 min_ts = ts;

918 sid = i;

919 }

920 }

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

922 ret = ff_subtitles_queue_read_packet(q, &idx_pkt);

923 if (ret < 0)

924 return ret;

925

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

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

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

929 psize = q->subs[q->current_sub_idx].pos - idx_pkt.pos;

930 } else {

931 int64_t fsize = avio_size(pb);

932 psize = fsize < 0 ? 0xffff : fsize - idx_pkt.pos;

933 }

934

935 avio_seek(pb, idx_pkt.pos, SEEK_SET);

936

937 av_init_packet(pkt);

938 pkt->size = 0;

939 pkt->data = NULL;

940

941 do {

942 int n, to_read, startcode;

943 int64_t pts, dts;

944 int64_t old_pos = avio_tell(pb), new_pos;

945 int pkt_size;

946

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

948 if (ret < 0) {

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

950 break;

951 goto fail;

952 }

953 to_read = ret & 0xffff;

954 new_pos = avio_tell(pb);

955 pkt_size = ret + (new_pos - old_pos);

956

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

958 if (total_read + pkt_size > psize)

959 break;

960 total_read += pkt_size;

961

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

963 if ((startcode & 0x1f) != s->streams[idx_pkt.stream_index]->id)

964 break;

965

966 ret = av_grow_packet(pkt, to_read);

967 if (ret < 0)

968 goto fail;

969

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

971 if (n < to_read)

972 pkt->size -= to_read - n;

973 } while (total_read < psize);

974

975 pkt->pts = pkt->dts = idx_pkt.pts;

976 pkt->pos = idx_pkt.pos;

977 pkt->stream_index = idx_pkt.stream_index;

978

979 av_packet_unref(&idx_pkt);

980 return 0;

981

982 fail:

983 av_packet_unref(pkt);

984 av_packet_unref(&idx_pkt);

985 return ret;

986 }

987

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

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

990 {

991 MpegDemuxContext *vobsub = s->priv_data;

992

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

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

995 * like in avformat_seek_file(). */

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

997 int i, ret = 0;

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

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

1000 min_ts = av_rescale_rnd(min_ts, time_base.den,

1001 time_base.num * (int64_t)AV_TIME_BASE,

1002 AV_ROUND_UP | AV_ROUND_PASS_MINMAX);

1003 max_ts = av_rescale_rnd(max_ts, time_base.den,

1004 time_base.num * (int64_t)AV_TIME_BASE,

1005 AV_ROUND_DOWN | AV_ROUND_PASS_MINMAX);

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

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

1008 min_ts, ts, max_ts, flags);

1009 if (r < 0)

1010 ret = r;

1011 }

1012 return ret;

1013 }

1014

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

1016 stream_index = 0;

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

1018 min_ts, ts, max_ts, flags);

1019 }

1020

1021 static int vobsub_read_close(AVFormatContext *s)

1022 {

1023 int i;

1024 MpegDemuxContext *vobsub = s->priv_data;

1025

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

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

1028 if (vobsub->sub_ctx)

1029 avformat_close_input(&vobsub->sub_ctx);

1030 return 0;

1031 }

1032

1033 static const AVOption options[] = {

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

1035 { NULL }

1036 };

1037

1038 static const AVClass vobsub_demuxer_class = {

1039 .class_name = "vobsub",

1040 .item_name = av_default_item_name,

1041 .option = options,

1042 .version = LIBAVUTIL_VERSION_INT,

1043 };

1044

1045 AVInputFormat ff_vobsub_demuxer = {

1046 .name = "vobsub",

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

1048 .priv_data_size = sizeof(MpegDemuxContext),

1049 .read_probe = vobsub_probe,

1050 .read_header = vobsub_read_header,

1051 .read_packet = vobsub_read_packet,

1052 .read_seek2 = vobsub_read_seek,

1053 .read_close = vobsub_read_close,

1054 .flags = AVFMT_SHOW_IDS,

1055 .extensions = "idx",

1056 .priv_class = &vobsub_demuxer_class,

1057 };

1058 #endif

NULL

#define NULL

Definition: coverity.c:32

val

const char const char void * val

Definition: avisynth_c.h:771

AV_CODEC_ID_MLP

Definition: avcodec.h:580

const char * s

Definition: avisynth_c.h:768

AVIOContext

Bytestream IO Context.

Definition: avio.h:161

AVERROR_INVALIDDATA

#define AVERROR_INVALIDDATA

Invalid data found when processing input.

Definition: error.h:59

AV_CODEC_ID_NONE

Definition: avcodec.h:216

avio_size

int64_t avio_size(AVIOContext *s)

Get the filesize.

Definition: aviobuf.c:336

av_bprintf

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

Definition: bprint.c:94

STREAM_TYPE_AUDIO_MPEG2

#define STREAM_TYPE_AUDIO_MPEG2

Definition: mpeg.h:52

AVOption

AVOption.

Definition: opt.h:246

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

AV_LOG_WARNING

#define AV_LOG_WARNING

Something somehow does not look correct.

Definition: log.h:182

LIBAVUTIL_VERSION_INT

#define LIBAVUTIL_VERSION_INT

Definition: version.h:85

AVPacket::pos

int64_t pos

byte position in stream, -1 if unknown

Definition: avcodec.h:1450

VIDEO_ID

#define VIDEO_ID

Definition: mpeg.h:42

avpriv_set_pts_info

void avpriv_set_pts_info(AVStream *s, 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:4820

ff_copy_whiteblacklists

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

Copies the whilelists from one context to the other.

Definition: utils.c:164

AV_CODEC_ID_VC1

Definition: avcodec.h:288

MAX_SYNC_SIZE

#define MAX_SYNC_SIZE

Definition: mpeg.c:38

AVCodecParameters::codec_id

enum AVCodecID codec_id

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

Definition: avcodec.h:3884

AVRational::num

int num

Numerator.

Definition: rational.h:59

AVStream::index

int index

stream index in AVFormatContext

Definition: avformat.h:874

AVPacket::size

int size

Definition: avcodec.h:1431

PACK_START_CODE

#define PACK_START_CODE

Definition: mpeg.h:28

avio_seek

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

fseek() equivalent for AVIOContext.

Definition: aviobuf.c:246

av_default_item_name

const char * av_default_item_name(void *ptr)

Return the context name.

Definition: log.c:191

ff_subtitles_queue_clean

void ff_subtitles_queue_clean(FFDemuxSubtitlesQueue *q)

Remove and destroy all the subtitles packets.

Definition: subtitles.c:297

AV_CODEC_ID_MPEG4

Definition: avcodec.h:230

avio_skip

int64_t avio_skip(AVIOContext *s, int64_t offset)

Skip given number of bytes forward.

Definition: aviobuf.c:331

SUB_SORT_POS_TS

sort by position, then timestamps

Definition: subtitles.h:31

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

STREAM_TYPE_VIDEO_MPEG1

#define STREAM_TYPE_VIDEO_MPEG1

Definition: mpeg.h:49

AVDISCARD_ALL

discard all

Definition: avcodec.h:794

AVInputFormat

Definition: avformat.h:642

pkt

static AVPacket pkt

Definition: demuxing_decoding.c:54

avio_rb16

unsigned int avio_rb16(AVIOContext *s)

Definition: aviobuf.c:786

AVFormatContext::ctx_flags

int ctx_flags

Flags signalling stream properties.

Definition: avformat.h:1391

MpegDemuxContext::dvd

int dvd

Definition: mpeg.c:130

AV_CODEC_ID_H264

Definition: avcodec.h:245

mpegps_read_header

static int mpegps_read_header(AVFormatContext *s)

Definition: mpeg.c:140

av_bprint_finalize

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

Finalize a print buffer.

Definition: bprint.c:235

AVFMT_SHOW_IDS

#define AVFMT_SHOW_IDS

Show format stream IDs numbers.

Definition: avformat.h:467

AVFormatContext

Format I/O context.

Definition: avformat.h:1342

AV_CODEC_ID_DVD_SUBTITLE

Definition: avcodec.h:643

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

av_assert0

#define av_assert0(cond)

assert() equivalent, that is always enabled.

Definition: avassert.h:37

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

uint8_t

Definition: audio_convert.c:194

AV_ROUND_UP

Round toward +infinity.

Definition: mathematics.h:83

nb_streams

static int nb_streams

Definition: ffprobe.c:276

av_malloc

#define av_malloc(s)

Definition: tableprint_vlc.h:31

AVMEDIA_TYPE_DATA

Opaque data information usually continuous.

Definition: avutil.h:203

AVFMTCTX_NOHEADER

#define AVFMTCTX_NOHEADER

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

Definition: avformat.h:1286

opt.h

AVOptions.

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

AV_LOG_TRACE

#define AV_LOG_TRACE

Extremely verbose debugging, useful for libav* development.

Definition: log.h:202

avio_rb32

unsigned int avio_rb32(AVIOContext *s)

Definition: aviobuf.c:801

end

static av_cold int end(AVCodecContext *avctx)

Definition: avrndec.c:90

AVStream::need_parsing

enum AVStreamParseType need_parsing

Definition: avformat.h:1091

AVStream::id

int id

Format-specific stream ID.

Definition: avformat.h:880

mpeg.h

AV_CODEC_ID_AAC

Definition: avcodec.h:553

avformat_new_stream

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

Add a new stream to a media file.

Definition: utils.c:4450

FFERROR_REDO

#define FFERROR_REDO

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

Definition: internal.h:644

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

AVFormatContext::streams

AVStream ** streams

A list of all streams in the file.

Definition: avformat.h:1410

SYSTEM_HEADER_START_CODE

#define SYSTEM_HEADER_START_CODE

Definition: mpeg.h:29

avformat_alloc_context

AVFormatContext * avformat_alloc_context(void)

Allocate an AVFormatContext.

Definition: options.c:144

avio_internal.h

AV_OPT_TYPE_STRING

Definition: opt.h:227

AVPacket::data

uint8_t * data

Definition: avcodec.h:1430

flags

static int flags

Definition: log.c:55

AVERROR_EOF

#define AVERROR_EOF

End of file.

Definition: error.h:55

PRIVATE_STREAM_1

#define PRIVATE_STREAM_1

Definition: mpeg.h:37

read_close

static av_cold int read_close(AVFormatContext *ctx)

Definition: libcdio.c:145

AV_LOG_VERBOSE

#define AV_LOG_VERBOSE

Detailed information.

Definition: log.h:192

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

size

ptrdiff_t size

Definition: opengl_enc.c:101

avio_tell

static av_always_inline int64_t avio_tell(AVIOContext *s)

ftell() equivalent for AVIOContext.

Definition: avio.h:557

header

static const uint8_t header[24]

Definition: sdr2.c:67

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

AV_CODEC_ID_PCM_DVD

Definition: avcodec.h:471

AVCodecParameters::channel_layout

uint64_t channel_layout

Audio only.

Definition: avcodec.h:3986

av_log

#define av_log(a,...)

Definition: tableprint_vlc.h:28

avio_read

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

Read size bytes from AVIOContext into buf.

Definition: aviobuf.c:648

STREAM_TYPE_AUDIO_AAC

#define STREAM_TYPE_AUDIO_AAC

Definition: mpeg.h:55

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_TRUEHD

Definition: avcodec.h:595

AVINDEX_KEYFRAME

#define AVINDEX_KEYFRAME

Definition: avformat.h:810

AV_CODEC_ID_PCM_ALAW

Definition: avcodec.h:459

AVCodecID

Identify the syntax and semantics of the bitstream.

Definition: avcodec.h:215

AV_LOG_ERROR

#define AV_LOG_ERROR

Something went wrong and cannot losslessly be recovered.

Definition: log.h:176

PRIVATE_STREAM_2

#define PRIVATE_STREAM_2

Definition: mpeg.h:39

AV_BPRINT_SIZE_UNLIMITED

#define AV_BPRINT_SIZE_UNLIMITED

AVFMT_TS_DISCONT

#define AVFMT_TS_DISCONT

Format allows timestamp discontinuities.

Definition: avformat.h:471

AVERROR

#define AVERROR(e)

Definition: error.h:43

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

MAX_LINE_SIZE

#define MAX_LINE_SIZE

Definition: vf_lut3d.c:249

check_pack_header

static int check_pack_header(const uint8_t *buf)

Definition: mpeg.c:62

av_bprint_init

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

Definition: bprint.c:69

AVFormatContext::url

char * url

input or output URL.

Definition: avformat.h:1438

const char * r

Definition: vf_curves.c:111

AV_LOG_DEBUG

#define AV_LOG_DEBUG

Stuff which is only useful for libav* developers.

Definition: log.h:197

AV_CODEC_ID_DTS

Definition: avcodec.h:555

AV_CODEC_ID_MP3

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

Definition: avcodec.h:552

AVCodecParameters::codec_type

enum AVMediaType codec_type

General type of the encoded data.

Definition: avcodec.h:3880

PADDING_STREAM

#define PADDING_STREAM

Definition: mpeg.h:38

line

Definition: graph2dot.c:48

AVMEDIA_TYPE_AUDIO

Definition: avutil.h:202

avassert.h

simple assert() macros that are a bit more flexible than ISO C assert().

internal.h

MpegDemuxContext

Definition: mpeg.c:125

ff_parse_pes_pts

static int64_t ff_parse_pes_pts(const uint8_t *buf)

Parse MPEG-PES five-byte timestamp.

Definition: mpeg.h:67

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

fail

#define fail()

Definition: checkasm.h:116

AVCodecParameters::extradata_size

int extradata_size

Size of the extradata content in bytes.

Definition: avcodec.h:3902

avio_r8

int avio_r8(AVIOContext *s)

Definition: aviobuf.c:639

subtitles.h

AVProbeData::buf_size

int buf_size

Size of buf except extra allocated bytes.

Definition: avformat.h:451

AVProbeData::buf

unsigned char * buf

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

Definition: avformat.h:450

AVFormatContext::nb_streams

unsigned int nb_streams

Number of elements in AVFormatContext.streams.

Definition: avformat.h:1398

av_find_input_format

AVInputFormat * av_find_input_format(const char *short_name)

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

Definition: format.c:118

AVIOContext::seekable

int seekable

A combination of AVIO_SEEKABLE_ flags or 0 when the stream is not seekable.

Definition: avio.h:260

AV_TIME_BASE

#define AV_TIME_BASE

Internal time base represented as integer.

Definition: avutil.h:254

FFDemuxSubtitlesQueue

Definition: subtitles.h:102

STREAM_TYPE_VIDEO_H264

#define STREAM_TYPE_VIDEO_H264

Definition: mpeg.h:57

read_probe

static int read_probe(AVProbeData *pd)

Definition: jvdec.c:55

find_next_start_code

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

Definition: mpeg.c:171

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

int32_t

Definition: audio_convert.c:194

MpegDemuxContext::sofdec

int sofdec

Definition: mpeg.c:129

AUDIO_ID

#define AUDIO_ID

Definition: mpeg.h:41

int n

Definition: avisynth_c.h:684

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

AVStream::metadata

AVDictionary * metadata

Definition: avformat.h:937

ff_get_line

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

Read a whole line of text from AVIOContext.

Definition: aviobuf.c:809

codec_id

enum AVCodecID codec_id

Definition: vaapi_decode.c:362

state

static struct @271 state

bprint.h

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

AV_CODEC_ID_MPEG2VIDEO

preferred ID for MPEG-1/2 video decoding

Definition: avcodec.h:220

FF_ARRAY_ELEMS

#define FF_ARRAY_ELEMS(a)

Definition: sinewin_tablegen_template.c:36

STREAM_TYPE_VIDEO_MPEG4

#define STREAM_TYPE_VIDEO_MPEG4

Definition: mpeg.h:56

MpegDemuxContext::psm_es_type

unsigned char psm_es_type[256]

Definition: mpeg.c:128

read_header

static int read_header(FFV1Context *f)

Definition: ffv1dec.c:530

AV_CODEC_ID_ADPCM_ADX

Definition: avcodec.h:499

AVStream

Stream structure.

Definition: avformat.h:873

read_packet

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

Definition: avio_reading.c:42

MpegDemuxContext::imkh_cctv

int imkh_cctv

Definition: mpeg.c:131

MpegDemuxContext::header_state

int32_t header_state

Definition: mpeg.c:127

MpegDemuxContext::raw_ac3

int raw_ac3

Definition: mpeg.c:132

AVIO_SEEKABLE_NORMAL

#define AVIO_SEEKABLE_NORMAL

Seeking works like for a local file.

Definition: avio.h:40

AV_DISPOSITION_DEFAULT

#define AV_DISPOSITION_DEFAULT

Definition: avformat.h:819

FF_FDEBUG_TS

#define FF_FDEBUG_TS

Definition: avformat.h:1624

iformat

static AVInputFormat * iformat

Definition: ffprobe.c:253

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

av_strdup

char * av_strdup(const char *s)

Duplicate a string.

Definition: mem.c:251

AVFormatContext::debug

int debug

Flags to enable debugging.

Definition: avformat.h:1623

AV_TIME_BASE_Q

#define AV_TIME_BASE_Q

Internal time base represented as fractional value.

Definition: avutil.h:260

AVFormatContext::pb

AVIOContext * pb

I/O context.

Definition: avformat.h:1384

#define ss

Definition: colorspacedsp_template.c:27

av_make_q

static AVRational av_make_q(int num, int den)

Create an AVRational.

Definition: rational.h:71

av_packet_unref

void av_packet_unref(AVPacket *pkt)

Wipe the packet.

Definition: avpacket.c:592

AV_CODEC_ID_AC3

Definition: avcodec.h:554

AV_CODEC_ID_PCM_MULAW

Definition: avcodec.h:458

buf

void * buf

Definition: avisynth_c.h:690

type

GLint GLenum type

Definition: opengl_enc.c:105

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

AV_CODEC_ID_DVD_NAV

Definition: avcodec.h:679

AVClass

Describe the class of an AVClass context structure.

Definition: log.h:67

AVRational

Rational number (pair of numerator and denominator).

Definition: rational.h:58

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

PROGRAM_STREAM_MAP

#define PROGRAM_STREAM_MAP

Definition: mpeg.h:36

AVMediaType

Definition: avutil.h:199

STREAM_TYPE_AUDIO_AC3

#define STREAM_TYPE_AUDIO_AC3

Definition: mpeg.h:60

AVPROBE_SCORE_EXTENSION

#define AVPROBE_SCORE_EXTENSION

score for file extension

Definition: avformat.h:458

AV_CODEC_ID_MP2

Definition: avcodec.h:551

AVProbeData

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

Definition: avformat.h:448

AV_ROUND_DOWN

Round toward -infinity.

Definition: mathematics.h:82

get_pts

static int64_t get_pts(AVIOContext *pb, int c)

Definition: mpeg.c:161

pts

static int64_t pts

Definition: transcode_aac.c:647

AV_CODEC_ID_CAVS

Definition: avcodec.h:305

AVERROR_DEMUXER_NOT_FOUND

#define AVERROR_DEMUXER_NOT_FOUND

Demuxer not found.

Definition: error.h:53

mpegps_read_packet

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

Definition: mpeg.c:486

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

AVCodecParameters::sample_rate

int sample_rate

Audio only.

Definition: avcodec.h:3994

AVPROBE_SCORE_MAX

#define AVPROBE_SCORE_MAX

maximum score

Definition: avformat.h:460

AVSTREAM_PARSE_FULL

full parsing and repack

Definition: avformat.h:793

avformat.h

Main libavformat public API header.

options

const OptionDef options[]

Definition: ffmpeg_opt.c:3292

if(ret< 0)

Definition: vf_mcdeint.c:279

static double c[64]

Definition: vsrc_mptestsrc.c:87

FFDemuxSubtitlesQueue::subs

AVPacket * subs

array of subtitles packets

Definition: subtitles.h:103

AVStream::disposition

int disposition

AV_DISPOSITION_* bit field.

Definition: avformat.h:926

av_grow_packet

int av_grow_packet(AVPacket *pkt, int grow_by)

Increase packet size, correctly zeroing padding.

Definition: avpacket.c:109

FFDemuxSubtitlesQueue::current_sub_idx

int current_sub_idx

current position for the read packet callback

Definition: subtitles.h:106

av_init_packet

void av_init_packet(AVPacket *pkt)

Initialize optional fields of a packet with default values.

Definition: avpacket.c:33

AVRational::den

int den

Denominator.

Definition: rational.h:60

check_pes

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

Definition: mpeg.c:40

avformat_close_input

void avformat_close_input(AVFormatContext **s)

Close an opened input AVFormatContext.

Definition: utils.c:4422

AV_ROUND_PASS_MINMAX

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

Definition: mathematics.h:108

av_free

#define av_free(p)

Definition: tableprint_vlc.h:34

len

int len

Definition: vorbis_enc_data.h:452

STREAM_TYPE_VIDEO_MPEG2

#define STREAM_TYPE_VIDEO_MPEG2

Definition: mpeg.h:50

AVFormatContext::priv_data

void * priv_data

Format private data.

Definition: avformat.h:1370

avformat_open_input

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

Open an input stream and read the header.

Definition: utils.c:537

AVCodecParameters::extradata

uint8_t * extradata

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

Definition: avcodec.h:3898

AVCodecParameters::channels

int channels

Audio only.

Definition: avcodec.h:3990

AVPacket::dts

int64_t dts

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

Definition: avcodec.h:1429

AVInputFormat::name

const char * name

A comma separated list of short names for the format.

Definition: avformat.h:647

AVMEDIA_TYPE_VIDEO

Definition: avutil.h:201

AVStream::codecpar

AVCodecParameters * codecpar

Codec parameters associated with this stream.

Definition: avformat.h:1020

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

avio_feof

int avio_feof(AVIOContext *s)

feof() equivalent for AVIOContext.

Definition: aviobuf.c:358

fsize

static int64_t fsize(FILE *f)

Definition: audiomatch.c:28

AVPacket::stream_index

int stream_index

Definition: avcodec.h:1432

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

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

AVMEDIA_TYPE_SUBTITLE

Definition: avutil.h:204

AV_CH_LAYOUT_MONO

#define AV_CH_LAYOUT_MONO

Definition: channel_layout.h:85

AVStream::discard

enum AVDiscard discard

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

Definition: avformat.h:928

STREAM_TYPE_AUDIO_MPEG1

#define STREAM_TYPE_AUDIO_MPEG1

Definition: mpeg.h:51

AVStream::request_probe

int request_probe

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

Definition: avformat.h:1124

AVPacket

This structure stores compressed data.

Definition: avcodec.h:1407

FFDemuxSubtitlesQueue::nb_subs

int nb_subs

number of subtitles packets

Definition: subtitles.h:104

ff_vobsub_demuxer

AVInputFormat ff_vobsub_demuxer

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

AVPacket::pts

int64_t pts

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

Definition: avcodec.h:1423

AV_NOPTS_VALUE

#define AV_NOPTS_VALUE

Undefined timestamp value.

Definition: avutil.h:248

buffer

GLuint buffer

Definition: opengl_enc.c:102

ff_mpegps_demuxer

AVInputFormat ff_mpegps_demuxer

Definition: mpeg.c:687

mpegps_probe

static int mpegps_probe(AVProbeData *p)

Definition: mpeg.c:67

Generated on Sun May 13 2018 02:04:06 for FFmpeg by doxygen 1.8.6