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

24 #include "mpeg.h"

26 #if CONFIG_VOBSUB_DEMUXER

27 # include "subtitles.h"

28 # include "libavutil/bprint.h"

29 # include "libavutil/opt.h"

30 #endif

32 #include "libavutil/avassert.h"

34 /*********************************************/

35 /* demux code */

37 #define MAX_SYNC_SIZE 100000

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

40 {

41 int pes1;

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

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

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

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

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

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

49 p += 2;

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

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

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

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

55 else

56 pes1 = *p == 0x0F;

58 return pes1 || pes2;

59 }

61 static int check_pack_header(const uint8_t *buf)

62 {

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

64 }

66 static int mpegps_probe(AVProbeData *p)

67 {

68 uint32_t code = -1;

69 int i;

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

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

72 int endpes = 0;

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

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

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

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

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

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

81 if (code == SYSTEM_HEADER_START_CODE)

82 sys++;

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

84 pspack++;

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

86 endpes = i + len;

87 vid++;

88 }

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

90 // and audio streams

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

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

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

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

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

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

98 }

99 }

100

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

102 score = AVPROBE_SCORE_EXTENSION / 2;

103

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

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

106

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

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

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

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

111 return pspack > 2 ? AVPROBE_SCORE_EXTENSION + 2

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

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

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

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

116 : AVPROBE_SCORE_EXTENSION / 2;

117

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

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

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

121 return score;

122 }

123

124 typedef struct MpegDemuxContext {

125 AVClass *class;

126 int32_t header_state;

127 unsigned char psm_es_type[256];

128 int sofdec;

129 int dvd;

130 int imkh_cctv;

131 #if CONFIG_VOBSUB_DEMUXER

132 AVFormatContext *sub_ctx;

133 FFDemuxSubtitlesQueue q[32];

134 char *sub_name;

135 #endif

136 } MpegDemuxContext;

137

138 static int mpegps_read_header(AVFormatContext *s)

139 {

140 MpegDemuxContext *m = s->priv_data;

141 char buffer[7] = { 0 };

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

143

144 m->header_state = 0xff;

145 s->ctx_flags |= AVFMTCTX_NOHEADER;

146

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

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

149 m->imkh_cctv = 1;

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

151 m->sofdec = 1;

152 } else

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

154

155 /* no need to do more */

156 return 0;

157 }

158

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

160 {

161 uint8_t buf[5];

162

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

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

165

166 return ff_parse_pes_pts(buf);

167 }

168

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

170 int32_t *header_state)

171 {

172 unsigned int state, v;

173 int val, n;

174

175 state = *header_state;

176 n = *size_ptr;

177 while (n > 0) {

178 if (avio_feof(pb))

179 break;

180 v = avio_r8(pb);

181 n--;

182 if (state == 0x000001) {

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

184 val = state;

185 goto found;

186 }

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

188 }

189 val = -1;

190

191 found:

192 *header_state = state;

193 *size_ptr = n;

194 return val;

195 }

196

197 /**

198 * Extract stream types from a program stream map

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

200 *

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

202 */

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

204 {

205 int psm_length, ps_info_length, es_map_length;

206

207 psm_length = avio_rb16(pb);

208 avio_r8(pb);

209 avio_r8(pb);

210 ps_info_length = avio_rb16(pb);

211

212 /* skip program_stream_info */

213 avio_skip(pb, ps_info_length);

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

215 /* Ignore es_map_length, trust psm_length */

216 es_map_length = psm_length - ps_info_length - 10;

217

218 /* at least one es available? */

219 while (es_map_length >= 4) {

220 unsigned char type = avio_r8(pb);

221 unsigned char es_id = avio_r8(pb);

222 uint16_t es_info_length = avio_rb16(pb);

223

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

225 m->psm_es_type[es_id] = type;

226 /* skip program_stream_info */

227 avio_skip(pb, es_info_length);

228 es_map_length -= 4 + es_info_length;

229 }

230 avio_rb32(pb); /* crc32 */

231 return 2 + psm_length;

232 }

233

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

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

236 */

237 static int mpegps_read_pes_header(AVFormatContext *s,

238 int64_t *ppos, int *pstart_code,

239 int64_t *ppts, int64_t *pdts)

240 {

241 MpegDemuxContext *m = s->priv_data;

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

243 int pes_ext, ext2_len, id_ext, skip;

244 int64_t pts, dts;

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

246

247 error_redo:

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

249 redo:

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

251 m->header_state = 0xff;

252 size = MAX_SYNC_SIZE;

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

254 last_sync = avio_tell(s->pb);

255 if (startcode < 0) {

256 if (avio_feof(s->pb))

257 return AVERROR_EOF;

258 // FIXME we should remember header_state

259 return FFERROR_REDO;

260 }

261

262 if (startcode == PACK_START_CODE)

263 goto redo;

264 if (startcode == SYSTEM_HEADER_START_CODE)

265 goto redo;

266 if (startcode == PADDING_STREAM) {

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

268 goto redo;

269 }

270 if (startcode == PRIVATE_STREAM_2) {

271 if (!m->sofdec) {

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

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

274 int bytesread = 0;

275 uint8_t *ps2buf = av_malloc(len);

276

277 if (ps2buf) {

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

279

280 if (bytesread != len) {

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

282 } else {

283 uint8_t *p = 0;

284 if (len >= 6)

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

286

287 if (p)

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

289

290 m->sofdec -= !m->sofdec;

291

292 if (m->sofdec < 0) {

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

294 /* PCI structure? */

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

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

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

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

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

300

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

302 mins <= 59 &&

303 secs <= 59 &&

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

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

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

307 endpts >= startpts);

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

309 /* DSI structure? */

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

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

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

313

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

315 mins <= 59 &&

316 secs <= 59 &&

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

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

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

320 }

321 }

322 }

323

324 av_free(ps2buf);

325

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

327 * could be allocated, just ignore it.

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

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

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

331 /* Skip back failed.

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

333 * if we can't skip back

334 */

335 goto redo;

336 }

337 } else {

338 /* No memory */

339 avio_skip(s->pb, len);

340 goto redo;

341 }

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

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

344 avio_skip(s->pb, len);

345 goto redo;

346 }

347 }

348 if (startcode == PROGRAM_STREAM_MAP) {

349 mpegps_psm_parse(m, s->pb);

350 goto redo;

351 }

352

353 /* find matching stream */

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

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

356 (startcode == 0x1bd) ||

357 (startcode == PRIVATE_STREAM_2) ||

358 (startcode == 0x1fd)))

359 goto redo;

360 if (ppos) {

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

362 }

363 len = avio_rb16(s->pb);

364 pts =

365 dts = AV_NOPTS_VALUE;

366 if (startcode != PRIVATE_STREAM_2)

367 {

368 /* stuffing */

369 for (;;) {

370 if (len < 1)

371 goto error_redo;

372 c = avio_r8(s->pb);

373 len--;

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

375 if (c != 0xff)

376 break;

377 }

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

379 /* buffer scale & size */

380 avio_r8(s->pb);

381 c = avio_r8(s->pb);

382 len -= 2;

383 }

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

385 dts =

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

387 len -= 4;

388 if (c & 0x10) {

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

390 len -= 5;

391 }

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

393 /* mpeg 2 PES */

394 flags = avio_r8(s->pb);

395 header_len = avio_r8(s->pb);

396 len -= 2;

397 if (header_len > len)

398 goto error_redo;

399 len -= header_len;

400 if (flags & 0x80) {

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

402 header_len -= 5;

403 if (flags & 0x40) {

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

405 header_len -= 5;

406 }

407 }

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

409 flags &= 0xC0;

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

411 }

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

413 pes_ext = avio_r8(s->pb);

414 header_len--;

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

416 * and P-STD buffer */

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

418 skip += skip & 0x9;

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

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

421 pes_ext = skip = 0;

422 }

423 avio_skip(s->pb, skip);

424 header_len -= skip;

425

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

427 ext2_len = avio_r8(s->pb);

428 header_len--;

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

430 id_ext = avio_r8(s->pb);

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

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

433 header_len--;

434 }

435 }

436 }

437 if (header_len < 0)

438 goto error_redo;

439 avio_skip(s->pb, header_len);

440 } else if (c != 0xf)

441 goto redo;

442 }

443

444 if (startcode == PRIVATE_STREAM_1) {

445 startcode = avio_r8(s->pb);

446 len--;

447 }

448 if (len < 0)

449 goto error_redo;

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

451 int i;

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

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

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

455 ff_reduce_index(s, i);

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

457 AVINDEX_KEYFRAME /* FIXME keyframe? */);

458 }

459 }

460 }

461

462 *pstart_code = startcode;

463 *ppts = pts;

464 *pdts = dts;

465 return len;

466 }

467

468 static int mpegps_read_packet(AVFormatContext *s,

469 AVPacket *pkt)

470 {

471 MpegDemuxContext *m = s->priv_data;

472 AVStream *st;

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

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

475 int request_probe= 0;

476 enum AVCodecID codec_id = AV_CODEC_ID_NONE;

477 enum AVMediaType type;

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

479

480 redo:

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

482 if (len < 0)

483 return len;

484

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

486 if (len < 4)

487 goto skip;

488

489 /* audio: skip header */

490 avio_r8(s->pb);

491 lpcm_header_len = avio_rb16(s->pb);

492 len -= 3;

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

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

495 avio_r8(s->pb);

496 len--;

497 }

498 }

499

500 /* now find stream */

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

502 st = s->streams[i];

503 if (st->id == startcode)

504 goto found;

505 }

506

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

508 if (es_type == STREAM_TYPE_VIDEO_MPEG1) {

509 codec_id = AV_CODEC_ID_MPEG2VIDEO;

510 type = AVMEDIA_TYPE_VIDEO;

511 } else if (es_type == STREAM_TYPE_VIDEO_MPEG2) {

512 codec_id = AV_CODEC_ID_MPEG2VIDEO;

513 type = AVMEDIA_TYPE_VIDEO;

514 } else if (es_type == STREAM_TYPE_AUDIO_MPEG1 ||

515 es_type == STREAM_TYPE_AUDIO_MPEG2) {

516 codec_id = AV_CODEC_ID_MP3;

517 type = AVMEDIA_TYPE_AUDIO;

518 } else if (es_type == STREAM_TYPE_AUDIO_AAC) {

519 codec_id = AV_CODEC_ID_AAC;

520 type = AVMEDIA_TYPE_AUDIO;

521 } else if (es_type == STREAM_TYPE_VIDEO_MPEG4) {

522 codec_id = AV_CODEC_ID_MPEG4;

523 type = AVMEDIA_TYPE_VIDEO;

524 } else if (es_type == STREAM_TYPE_VIDEO_H264) {

525 codec_id = AV_CODEC_ID_H264;

526 type = AVMEDIA_TYPE_VIDEO;

527 } else if (es_type == STREAM_TYPE_AUDIO_AC3) {

528 codec_id = AV_CODEC_ID_AC3;

529 type = AVMEDIA_TYPE_AUDIO;

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

531 codec_id = AV_CODEC_ID_PCM_MULAW;

532 type = AVMEDIA_TYPE_AUDIO;

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

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

535 unsigned char buf[8];

536

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

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

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

540 codec_id = AV_CODEC_ID_CAVS;

541 else

542 request_probe= 1;

543 type = AVMEDIA_TYPE_VIDEO;

544 } else if (startcode == PRIVATE_STREAM_2) {

545 type = AVMEDIA_TYPE_DATA;

546 codec_id = AV_CODEC_ID_DVD_NAV;

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

548 type = AVMEDIA_TYPE_AUDIO;

549 if (m->sofdec > 0) {

550 codec_id = AV_CODEC_ID_ADPCM_ADX;

551 // Auto-detect AC-3

552 request_probe = 50;

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

554 codec_id = AV_CODEC_ID_PCM_ALAW;

555 request_probe = 50;

556 } else {

557 codec_id = AV_CODEC_ID_MP2;

558 if (m->imkh_cctv)

559 request_probe = 25;

560 }

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

562 type = AVMEDIA_TYPE_AUDIO;

563 codec_id = AV_CODEC_ID_AC3;

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

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

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

567 type = AVMEDIA_TYPE_AUDIO;

568 codec_id = AV_CODEC_ID_DTS;

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

570 type = AVMEDIA_TYPE_AUDIO;

571 if (lpcm_header_len == 6 || startcode == 0xa1) {

572 codec_id = AV_CODEC_ID_MLP;

573 } else {

574 codec_id = AV_CODEC_ID_PCM_DVD;

575 }

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

577 type = AVMEDIA_TYPE_AUDIO;

578 codec_id = AV_CODEC_ID_TRUEHD;

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

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

581 type = AVMEDIA_TYPE_AUDIO;

582 codec_id = AV_CODEC_ID_AC3;

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

584 type = AVMEDIA_TYPE_SUBTITLE;

585 codec_id = AV_CODEC_ID_DVD_SUBTITLE;

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

587 type = AVMEDIA_TYPE_VIDEO;

588 codec_id = AV_CODEC_ID_VC1;

589 } else {

590 skip:

591 /* skip packet */

592 avio_skip(s->pb, len);

593 goto redo;

594 }

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

596 st = avformat_new_stream(s, NULL);

597 if (!st)

598 goto skip;

599 st->id = startcode;

600 st->codecpar->codec_type = type;

601 st->codecpar->codec_id = codec_id;

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

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

604 st->codecpar->channels = 1;

605 st->codecpar->channel_layout = AV_CH_LAYOUT_MONO;

606 st->codecpar->sample_rate = 8000;

607 }

608 st->request_probe = request_probe;

609 st->need_parsing = AVSTREAM_PARSE_FULL;

610

611 found:

612 if (st->discard >= AVDISCARD_ALL)

613 goto skip;

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

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

616 if (len < 6)

617 goto skip;

618 avio_skip(s->pb, 6);

619 len -=6;

620 }

621 }

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

623

624 pkt->pts = pts;

625 pkt->dts = dts;

626 pkt->pos = dummy_pos;

627 pkt->stream_index = st->index;

628

629 if (s->debug & FF_FDEBUG_TS)

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

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

632 pkt->size);

633

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

635 }

636

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

638 int64_t *ppos, int64_t pos_limit)

639 {

640 int len, startcode;

641 int64_t pos, pts, dts;

642

643 pos = *ppos;

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

645 return AV_NOPTS_VALUE;

646

647 for (;;) {

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

649 if (len < 0) {

650 if (s->debug & FF_FDEBUG_TS)

651 av_log(s, AV_LOG_TRACE, "none (ret=%d)\n", len);

652 return AV_NOPTS_VALUE;

653 }

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

655 dts != AV_NOPTS_VALUE) {

656 break;

657 }

658 avio_skip(s->pb, len);

659 }

660 if (s->debug & FF_FDEBUG_TS)

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

662 pos, dts, dts / 90000.0);

663 *ppos = pos;

664 return dts;

665 }

666

667 AVInputFormat ff_mpegps_demuxer = {

668 .name = "mpeg",

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

670 .priv_data_size = sizeof(MpegDemuxContext),

671 .read_probe = mpegps_probe,

672 .read_header = mpegps_read_header,

673 .read_packet = mpegps_read_packet,

674 .read_timestamp = mpegps_read_dts,

675 .flags = AVFMT_SHOW_IDS | AVFMT_TS_DISCONT,

676 };

677

678 #if CONFIG_VOBSUB_DEMUXER

679

680 #define REF_STRING "# VobSub index file,"

681 #define MAX_LINE_SIZE 2048

682

683 static int vobsub_probe(AVProbeData *p)

684 {

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

686 return AVPROBE_SCORE_MAX;

687 return 0;

688 }

689

690 static int vobsub_read_header(AVFormatContext *s)

691 {

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

693 MpegDemuxContext *vobsub = s->priv_data;

694 size_t fname_len;

695 char *header_str;

696 AVBPrint header;

697 int64_t delay = 0;

698 AVStream *st = NULL;

699 int stream_id = -1;

700 char id[64] = {0};

701 char alt[MAX_LINE_SIZE] = {0};

702 AVInputFormat *iformat;

703

704 if (!vobsub->sub_name) {

705 char *ext;

706 vobsub->sub_name = av_strdup(s->filename);

707 if (!vobsub->sub_name) {

708 ret = AVERROR(ENOMEM);

709 goto end;

710 }

711

712 fname_len = strlen(vobsub->sub_name);

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

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

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

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

717 ret = AVERROR_INVALIDDATA;

718 goto end;

719 }

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

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

722 }

723

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

725 ret = AVERROR_DEMUXER_NOT_FOUND;

726 goto end;

727 }

728

729 vobsub->sub_ctx = avformat_alloc_context();

730 if (!vobsub->sub_ctx) {

731 ret = AVERROR(ENOMEM);

732 goto end;

733 }

734

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

736 goto end;

737

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

739 if (ret < 0) {

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

741 goto end;

742 }

743

744 av_bprint_init(&header, 0, AV_BPRINT_SIZE_UNLIMITED);

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

746 char line[MAX_LINE_SIZE];

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

748

749 if (!len)

750 break;

751

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

753

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

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

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

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

758 strcpy(id, "und");

759 stream_id = 0;

760 }

761

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

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

764 ret = AVERROR(EINVAL);

765 goto end;

766 }

767

768 header_parsed = 1;

769 alt[0] = '0円';

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

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

772

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

774

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

776 AVPacket *sub;

777 int hh, mm, ss, ms;

778 int64_t pos, timestamp;

779 const char *p = line + 10;

780

781 if (stream_id == -1) {

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

783 ret = AVERROR_INVALIDDATA;

784 goto end;

785 }

786

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

788 st = avformat_new_stream(s, NULL);

789 if (!st) {

790 ret = AVERROR(ENOMEM);

791 goto end;

792 }

793 st->id = stream_id;

794 st->codecpar->codec_type = AVMEDIA_TYPE_SUBTITLE;

795 st->codecpar->codec_id = AV_CODEC_ID_DVD_SUBTITLE;

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

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

798 if (alt[0])

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

800 }

801

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

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

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

805 "abort parsing\n", line);

806 ret = AVERROR_INVALIDDATA;

807 goto end;

808 }

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

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

811

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

813 if (!sub) {

814 ret = AVERROR(ENOMEM);

815 goto end;

816 }

817 sub->pos = pos;

818 sub->pts = timestamp;

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

820

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

822 const char *p = line + 4;

823

824 while (*p == ' ')

825 p++;

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

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

828 header_parsed = 1;

829

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

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

832 const char *p = line + 6;

833

834 while (*p == ' ')

835 p++;

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

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

838 p++;

839 }

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

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

842

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

844 const char *p = line + 8;

845

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

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

848

849 } else if (!header_parsed) {

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

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

852 }

853 }

854

855 if (langidx < s->nb_streams)

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

857

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

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

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

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

862 }

863

864 if (!av_bprint_is_complete(&header)) {

865 av_bprint_finalize(&header, NULL);

866 ret = AVERROR(ENOMEM);

867 goto end;

868 }

869 av_bprint_finalize(&header, &header_str);

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

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

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

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

874 }

875 av_free(header_str);

876

877 end:

878 return ret;

879 }

880

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

882 {

883 MpegDemuxContext *vobsub = s->priv_data;

884 FFDemuxSubtitlesQueue *q;

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

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

887 AVPacket idx_pkt = { 0 };

888

889 int64_t min_ts = INT64_MAX;

890 int sid = 0;

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

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

893 int64_t ts;

894 av_assert0(tmpq->nb_subs);

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

896 if (ts < min_ts) {

897 min_ts = ts;

898 sid = i;

899 }

900 }

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

902 ret = ff_subtitles_queue_read_packet(q, &idx_pkt);

903 if (ret < 0)

904 return ret;

905

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

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

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

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

910 } else {

911 int64_t fsize = avio_size(pb);

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

913 }

914

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

916

917 av_init_packet(pkt);

918 pkt->size = 0;

919 pkt->data = NULL;

920

921 do {

922 int n, to_read, startcode;

923 int64_t pts, dts;

924 int64_t old_pos = avio_tell(pb), new_pos;

925 int pkt_size;

926

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

928 if (ret < 0) {

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

930 break;

931 goto fail;

932 }

933 to_read = ret & 0xffff;

934 new_pos = avio_tell(pb);

935 pkt_size = ret + (new_pos - old_pos);

936

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

938 if (total_read + pkt_size > psize)

939 break;

940 total_read += pkt_size;

941

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

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

944 break;

945

946 ret = av_grow_packet(pkt, to_read);

947 if (ret < 0)

948 goto fail;

949

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

951 if (n < to_read)

952 pkt->size -= to_read - n;

953 } while (total_read < psize);

954

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

956 pkt->pos = idx_pkt.pos;

957 pkt->stream_index = idx_pkt.stream_index;

958

959 av_packet_unref(&idx_pkt);

960 return 0;

961

962 fail:

963 av_packet_unref(pkt);

964 av_packet_unref(&idx_pkt);

965 return ret;

966 }

967

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

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

970 {

971 MpegDemuxContext *vobsub = s->priv_data;

972

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

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

975 * like in avformat_seek_file(). */

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

977 int i, ret = 0;

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

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

980 min_ts = av_rescale_rnd(min_ts, time_base.den,

981 time_base.num * (int64_t)AV_TIME_BASE,

982 AV_ROUND_UP | AV_ROUND_PASS_MINMAX);

983 max_ts = av_rescale_rnd(max_ts, time_base.den,

984 time_base.num * (int64_t)AV_TIME_BASE,

985 AV_ROUND_DOWN | AV_ROUND_PASS_MINMAX);

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

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

988 min_ts, ts, max_ts, flags);

989 if (r < 0)

990 ret = r;

991 }

992 return ret;

993 }

994

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

996 stream_index = 0;

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

998 min_ts, ts, max_ts, flags);

999 }

1000

1001 static int vobsub_read_close(AVFormatContext *s)

1002 {

1003 int i;

1004 MpegDemuxContext *vobsub = s->priv_data;

1005

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

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

1008 if (vobsub->sub_ctx)

1009 avformat_close_input(&vobsub->sub_ctx);

1010 return 0;

1011 }

1012

1013 static const AVOption options[] = {

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

1015 { NULL }

1016 };

1017

1018 static const AVClass vobsub_demuxer_class = {

1019 .class_name = "vobsub",

1020 .item_name = av_default_item_name,

1021 .option = options,

1022 .version = LIBAVUTIL_VERSION_INT,

1023 };

1024

1025 AVInputFormat ff_vobsub_demuxer = {

1026 .name = "vobsub",

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

1028 .priv_data_size = sizeof(MpegDemuxContext),

1029 .read_probe = vobsub_probe,

1030 .read_header = vobsub_read_header,

1031 .read_packet = vobsub_read_packet,

1032 .read_seek2 = vobsub_read_seek,

1033 .read_close = vobsub_read_close,

1034 .flags = AVFMT_SHOW_IDS,

1035 .extensions = "idx",

1036 .priv_class = &vobsub_demuxer_class,

1037 };

1038 #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:585

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

avio_size

int64_t avio_size(AVIOContext *s)

Get the filesize.

Definition: aviobuf.c:334

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

state

static struct @260 state

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

AVPacket::pos

int64_t pos

byte position in stream, -1 if unknown

Definition: avcodec.h:1699

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

ff_copy_whiteblacklists

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

Copies the whilelists from one context to the other.

Definition: utils.c:145

AV_CODEC_ID_VC1

Definition: avcodec.h:290

MAX_SYNC_SIZE

#define MAX_SYNC_SIZE

Definition: mpeg.c:37

AVCodecParameters::codec_id

enum AVCodecID codec_id

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

Definition: avcodec.h:4152

AVRational::num

int num

Numerator.

Definition: rational.h:59

AVStream::index

int index

stream index in AVFormatContext

Definition: avformat.h:890

AVPacket::size

int size

Definition: avcodec.h:1680

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

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

avio_skip

int64_t avio_skip(AVIOContext *s, int64_t offset)

Skip given number of bytes forward.

Definition: aviobuf.c:329

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

STREAM_TYPE_VIDEO_MPEG1

#define STREAM_TYPE_VIDEO_MPEG1

Definition: mpeg.h:49

AVDISCARD_ALL

discard all

Definition: avcodec.h:830

AVInputFormat

Definition: avformat.h:659

pkt

static AVPacket pkt

Definition: demuxing_decoding.c:54

avio_rb16

unsigned int avio_rb16(AVIOContext *s)

Definition: aviobuf.c:775

AVFormatContext::ctx_flags

int ctx_flags

Flags signalling stream properties.

Definition: avformat.h:1398

MpegDemuxContext::dvd

int dvd

Definition: mpeg.c:129

AV_CODEC_ID_H264

Definition: avcodec.h:247

mpegps_read_header

static int mpegps_read_header(AVFormatContext *s)

Definition: mpeg.c:138

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

AVFormatContext

Format I/O context.

Definition: avformat.h:1349

AV_CODEC_ID_DVD_SUBTITLE

Definition: avcodec.h:647

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

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

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

end

static av_cold int end(AVCodecContext *avctx)

Definition: avrndec.c:90

AVStream::need_parsing

enum AVStreamParseType need_parsing

Definition: avformat.h:1081

AVStream::id

int id

Format-specific stream ID.

Definition: avformat.h:896

mpeg.h

AV_CODEC_ID_AAC

Definition: avcodec.h:558

avformat_new_stream

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

Add a new stream to a media file.

Definition: utils.c:4367

FFERROR_REDO

#define FFERROR_REDO

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

Definition: internal.h:607

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

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

AV_OPT_TYPE_STRING

Definition: opt.h:227

AVPacket::data

uint8_t * data

Definition: avcodec.h:1679

flags

static int flags

Definition: log.c:57

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

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

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

options

const OptionDef options[]

Definition: ffserver.c:3948

AV_CODEC_ID_PCM_DVD

Definition: avcodec.h:473

AVCodecParameters::channel_layout

uint64_t channel_layout

Audio only.

Definition: avcodec.h:4254

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

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

AVINDEX_KEYFRAME

#define AVINDEX_KEYFRAME

Definition: avformat.h:827

AV_CODEC_ID_PCM_ALAW

Definition: avcodec.h:461

AVCodecID

Identify the syntax and semantics of the bitstream.

Definition: avcodec.h:214

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

av_default_item_name

Definition: libopenh264enc.c:78

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

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

av_bprint_init

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

Definition: bprint.c:69

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

AV_CODEC_ID_MP3

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

Definition: avcodec.h:557

AVCodecParameters::codec_type

enum AVMediaType codec_type

General type of the encoded data.

Definition: avcodec.h:4148

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

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

AVCodecParameters::extradata_size

int extradata_size

Size of the extradata content in bytes.

Definition: avcodec.h:4170

avio_r8

int avio_r8(AVIOContext *s)

Definition: aviobuf.c:628

subtitles.h

AVProbeData::buf_size

int buf_size

Size of buf except extra allocated bytes.

Definition: avformat.h:464

AVProbeData::buf

unsigned char * buf

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

Definition: avformat.h:463

AVFormatContext::nb_streams

unsigned int nb_streams

Number of elements in AVFormatContext.streams.

Definition: avformat.h:1405

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

AVIOContext::seekable

int seekable

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

Definition: avio.h:261

AVFormatContext::filename

char filename[1024]

input or output filename

Definition: avformat.h:1425

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

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

int32_t

Definition: audio_convert.c:194

MpegDemuxContext::sofdec

int sofdec

Definition: mpeg.c:128

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

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

codec_id

enum AVCodecID codec_id

Definition: vaapi_decode.c:235

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

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

read_header

static int read_header(FFV1Context *f)

Definition: ffv1dec.c:528

AV_CODEC_ID_ADPCM_ADX

Definition: avcodec.h:501

AVStream

Stream structure.

Definition: avformat.h:889

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

MpegDemuxContext::header_state

int32_t header_state

Definition: mpeg.c:126

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

FF_FDEBUG_TS

#define FF_FDEBUG_TS

Definition: avformat.h:1611

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

AVFormatContext::debug

int debug

Flags to enable debugging.

Definition: avformat.h:1610

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

#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:618

AV_CODEC_ID_AC3

Definition: avcodec.h:559

AV_CODEC_ID_PCM_MULAW

Definition: avcodec.h:460

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

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

AV_CODEC_ID_MP2

Definition: avcodec.h:556

AVProbeData

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

Definition: avformat.h:461

AV_ROUND_DOWN

Round toward -infinity.

Definition: mathematics.h:82

get_pts

static int64_t get_pts(AVIOContext *pb, int c)

Definition: mpeg.c:159

pts

static int64_t pts

Global timestamp for the audio frames.

Definition: transcode_aac.c:567

AV_CODEC_ID_CAVS

Definition: avcodec.h:307

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

AVCodecParameters::sample_rate

int sample_rate

Audio only.

Definition: avcodec.h:4262

AVPROBE_SCORE_MAX

#define AVPROBE_SCORE_MAX

maximum score

Definition: avformat.h:473

AVSTREAM_PARSE_FULL

full parsing and repack

Definition: avformat.h:810

avformat.h

Main libavformat public API header.

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

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

avformat_close_input

void avformat_close_input(AVFormatContext **s)

Close an opened input AVFormatContext.

Definition: utils.c:4339

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

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

AVCodecParameters::extradata

uint8_t * extradata

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

Definition: avcodec.h:4166

AVCodecParameters::channels

int channels

Audio only.

Definition: avcodec.h:4258

AVPacket::dts

int64_t dts

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

Definition: avcodec.h:1678

AVInputFormat::name

const char * name

A comma separated list of short names for the format.

Definition: avformat.h:664

AVMEDIA_TYPE_VIDEO

Definition: avutil.h:201

AVStream::codecpar

AVCodecParameters * codecpar

Definition: avformat.h:1252

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

avio_feof

int avio_feof(AVIOContext *s)

feof() equivalent for AVIOContext.

Definition: aviobuf.c:356

fsize

static int64_t fsize(FILE *f)

Definition: audiomatch.c:28

AVPacket::stream_index

int stream_index

Definition: avcodec.h:1681

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

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

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

AVPacket

This structure stores compressed data.

Definition: avcodec.h:1656

FFDemuxSubtitlesQueue::nb_subs

int nb_subs

number of subtitles packets

Definition: subtitles.h:104

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

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

mpegps_probe

static int mpegps_probe(AVProbeData *p)

Definition: mpeg.c:66

Generated on Fri Jan 12 2018 01:48:03 for FFmpeg by doxygen 1.8.6