FFmpeg: libavformat/mpeg.c Source File

FFmpeg

[フレーム]

libavformat

mpeg.c

Go to the documentation of this file.

1 /*

2 * MPEG1/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 #endif

31 #include "libavutil/avassert.h"

33 /*********************************************/

34 /* demux code */

36 #define MAX_SYNC_SIZE 100000

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

39 {

40 int pes1;

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

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

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

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

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

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

48 p += 2;

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

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

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

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

54 else

55 pes1 = *p == 0x0F;

57 return pes1 || pes2;

58 }

60 static int check_pack_header(const uint8_t *buf)

61 {

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

63 }

65 static int mpegps_probe(AVProbeData *p)

66 {

67 uint32_t code = -1;

68 int i;

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

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

71 int endpes = 0;

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

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

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

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

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

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

80 if (code == SYSTEM_HEADER_START_CODE)

81 sys++;

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

83 pspack++;

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

85 endpes = i + len;

86 vid++;

87 }

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

89 // and audio streams

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

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

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

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

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

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

97 }

98 }

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

101 score = AVPROBE_SCORE_EXTENSION / 2;

102

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

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

105

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

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

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

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

110 return pspack > 2 ? AVPROBE_SCORE_EXTENSION + 2

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

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

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

114 return (audio > 12 || vid > 3 + 2 * invalid) ? AVPROBE_SCORE_EXTENSION + 2

115 : AVPROBE_SCORE_EXTENSION / 2;

116

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

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

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

120 return score;

121 }

122

123 typedef struct MpegDemuxContext {

124 int32_t header_state;

125 unsigned char psm_es_type[256];

126 int sofdec;

127 int dvd;

128 int imkh_cctv;

129 #if CONFIG_VOBSUB_DEMUXER

130 AVFormatContext *sub_ctx;

131 FFDemuxSubtitlesQueue q[32];

132 #endif

133 } MpegDemuxContext;

134

135 static int mpegps_read_header(AVFormatContext *s)

136 {

137 MpegDemuxContext *m = s->priv_data;

138 char buffer[7];

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

140

141 m->header_state = 0xff;

142 s->ctx_flags |= AVFMTCTX_NOHEADER;

143

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

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

146 m->imkh_cctv = 1;

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

148 m->sofdec = 1;

149 } else

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

151

152 /* no need to do more */

153 return 0;

154 }

155

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

157 {

158 uint8_t buf[5];

159

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

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

162

163 return ff_parse_pes_pts(buf);

164 }

165

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

167 int32_t *header_state)

168 {

169 unsigned int state, v;

170 int val, n;

171

172 state = *header_state;

173 n = *size_ptr;

174 while (n > 0) {

175 if (avio_feof(pb))

176 break;

177 v = avio_r8(pb);

178 n--;

179 if (state == 0x000001) {

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

181 val = state;

182 goto found;

183 }

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

185 }

186 val = -1;

187

188 found:

189 *header_state = state;

190 *size_ptr = n;

191 return val;

192 }

193

194 /**

195 * Extract stream types from a program stream map

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

197 *

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

199 */

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

201 {

202 int psm_length, ps_info_length, es_map_length;

203

204 psm_length = avio_rb16(pb);

205 avio_r8(pb);

206 avio_r8(pb);

207 ps_info_length = avio_rb16(pb);

208

209 /* skip program_stream_info */

210 avio_skip(pb, ps_info_length);

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

212 /* Ignore es_map_length, trust psm_length */

213 es_map_length = psm_length - ps_info_length - 10;

214

215 /* at least one es available? */

216 while (es_map_length >= 4) {

217 unsigned char type = avio_r8(pb);

218 unsigned char es_id = avio_r8(pb);

219 uint16_t es_info_length = avio_rb16(pb);

220

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

222 m->psm_es_type[es_id] = type;

223 /* skip program_stream_info */

224 avio_skip(pb, es_info_length);

225 es_map_length -= 4 + es_info_length;

226 }

227 avio_rb32(pb); /* crc32 */

228 return 2 + psm_length;

229 }

230

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

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

233 */

234 static int mpegps_read_pes_header(AVFormatContext *s,

235 int64_t *ppos, int *pstart_code,

236 int64_t *ppts, int64_t *pdts)

237 {

238 MpegDemuxContext *m = s->priv_data;

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

240 int pes_ext, ext2_len, id_ext, skip;

241 int64_t pts, dts;

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

243

244 error_redo:

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

246 redo:

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

248 m->header_state = 0xff;

249 size = MAX_SYNC_SIZE;

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

251 last_sync = avio_tell(s->pb);

252 if (startcode < 0) {

253 if (avio_feof(s->pb))

254 return AVERROR_EOF;

255 // FIXME we should remember header_state

256 return AVERROR(EAGAIN);

257 }

258

259 if (startcode == PACK_START_CODE)

260 goto redo;

261 if (startcode == SYSTEM_HEADER_START_CODE)

262 goto redo;

263 if (startcode == PADDING_STREAM) {

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

265 goto redo;

266 }

267 if (startcode == PRIVATE_STREAM_2) {

268 if (!m->sofdec) {

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

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

271 int bytesread = 0;

272 uint8_t *ps2buf = av_malloc(len);

273

274 if (ps2buf) {

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

276

277 if (bytesread != len) {

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

279 } else {

280 uint8_t *p = 0;

281 if (len >= 6)

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

283

284 if (p)

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

286

287 m->sofdec -= !m->sofdec;

288

289 if (m->sofdec < 0) {

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

291 /* PCI structure? */

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

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

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

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

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

297

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

299 mins <= 59 &&

300 secs <= 59 &&

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

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

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

304 endpts >= startpts);

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

306 /* DSI structure? */

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

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

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

310

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

312 mins <= 59 &&

313 secs <= 59 &&

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

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

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

317 }

318 }

319 }

320

321 av_free(ps2buf);

322

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

324 * could be allocated, just ignore it.

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

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

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

328 /* Skip back failed.

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

330 * if we can't skip back

331 */

332 goto redo;

333 }

334 } else {

335 /* No memory */

336 avio_skip(s->pb, len);

337 goto redo;

338 }

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

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

341 avio_skip(s->pb, len);

342 goto redo;

343 }

344 }

345 if (startcode == PROGRAM_STREAM_MAP) {

346 mpegps_psm_parse(m, s->pb);

347 goto redo;

348 }

349

350 /* find matching stream */

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

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

353 (startcode == 0x1bd) ||

354 (startcode == PRIVATE_STREAM_2) ||

355 (startcode == 0x1fd)))

356 goto redo;

357 if (ppos) {

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

359 }

360 len = avio_rb16(s->pb);

361 pts =

362 dts = AV_NOPTS_VALUE;

363 if (startcode != PRIVATE_STREAM_2)

364 {

365 /* stuffing */

366 for (;;) {

367 if (len < 1)

368 goto error_redo;

369 c = avio_r8(s->pb);

370 len--;

371 /* XXX: for mpeg1, should test only bit 7 */

372 if (c != 0xff)

373 break;

374 }

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

376 /* buffer scale & size */

377 avio_r8(s->pb);

378 c = avio_r8(s->pb);

379 len -= 2;

380 }

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

382 dts =

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

384 len -= 4;

385 if (c & 0x10) {

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

387 len -= 5;

388 }

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

390 /* mpeg 2 PES */

391 flags = avio_r8(s->pb);

392 header_len = avio_r8(s->pb);

393 len -= 2;

394 if (header_len > len)

395 goto error_redo;

396 len -= header_len;

397 if (flags & 0x80) {

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

399 header_len -= 5;

400 if (flags & 0x40) {

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

402 header_len -= 5;

403 }

404 }

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

406 flags &= 0xC0;

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

408 }

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

410 pes_ext = avio_r8(s->pb);

411 header_len--;

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

413 * and P-STD buffer */

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

415 skip += skip & 0x9;

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

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

418 pes_ext = skip = 0;

419 }

420 avio_skip(s->pb, skip);

421 header_len -= skip;

422

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

424 ext2_len = avio_r8(s->pb);

425 header_len--;

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

427 id_ext = avio_r8(s->pb);

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

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

430 header_len--;

431 }

432 }

433 }

434 if (header_len < 0)

435 goto error_redo;

436 avio_skip(s->pb, header_len);

437 } else if (c != 0xf)

438 goto redo;

439 }

440

441 if (startcode == PRIVATE_STREAM_1) {

442 startcode = avio_r8(s->pb);

443 len--;

444 }

445 if (len < 0)

446 goto error_redo;

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

448 int i;

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

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

451 s->pb->seekable /* index useless on streams anyway */) {

452 ff_reduce_index(s, i);

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

454 AVINDEX_KEYFRAME /* FIXME keyframe? */);

455 }

456 }

457 }

458

459 *pstart_code = startcode;

460 *ppts = pts;

461 *pdts = dts;

462 return len;

463 }

464

465 static int mpegps_read_packet(AVFormatContext *s,

466 AVPacket *pkt)

467 {

468 MpegDemuxContext *m = s->priv_data;

469 AVStream *st;

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

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

472 int request_probe= 0;

473 enum AVCodecID codec_id = AV_CODEC_ID_NONE;

474 enum AVMediaType type;

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

476

477 redo:

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

479 if (len < 0)

480 return len;

481

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

483 if (len < 4)

484 goto skip;

485

486 /* audio: skip header */

487 avio_r8(s->pb);

488 lpcm_header_len = avio_rb16(s->pb);

489 len -= 3;

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

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

492 avio_r8(s->pb);

493 len--;

494 }

495 }

496

497 /* now find stream */

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

499 st = s->streams[i];

500 if (st->id == startcode)

501 goto found;

502 }

503

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

505 if (es_type == STREAM_TYPE_VIDEO_MPEG1) {

506 codec_id = AV_CODEC_ID_MPEG2VIDEO;

507 type = AVMEDIA_TYPE_VIDEO;

508 } else if (es_type == STREAM_TYPE_VIDEO_MPEG2) {

509 codec_id = AV_CODEC_ID_MPEG2VIDEO;

510 type = AVMEDIA_TYPE_VIDEO;

511 } else if (es_type == STREAM_TYPE_AUDIO_MPEG1 ||

512 es_type == STREAM_TYPE_AUDIO_MPEG2) {

513 codec_id = AV_CODEC_ID_MP3;

514 type = AVMEDIA_TYPE_AUDIO;

515 } else if (es_type == STREAM_TYPE_AUDIO_AAC) {

516 codec_id = AV_CODEC_ID_AAC;

517 type = AVMEDIA_TYPE_AUDIO;

518 } else if (es_type == STREAM_TYPE_VIDEO_MPEG4) {

519 codec_id = AV_CODEC_ID_MPEG4;

520 type = AVMEDIA_TYPE_VIDEO;

521 } else if (es_type == STREAM_TYPE_VIDEO_H264) {

522 codec_id = AV_CODEC_ID_H264;

523 type = AVMEDIA_TYPE_VIDEO;

524 } else if (es_type == STREAM_TYPE_AUDIO_AC3) {

525 codec_id = AV_CODEC_ID_AC3;

526 type = AVMEDIA_TYPE_AUDIO;

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

528 codec_id = AV_CODEC_ID_PCM_MULAW;

529 type = AVMEDIA_TYPE_AUDIO;

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

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

532 unsigned char buf[8];

533

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

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

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

537 codec_id = AV_CODEC_ID_CAVS;

538 else

539 request_probe= 1;

540 type = AVMEDIA_TYPE_VIDEO;

541 } else if (startcode == PRIVATE_STREAM_2) {

542 type = AVMEDIA_TYPE_DATA;

543 codec_id = AV_CODEC_ID_DVD_NAV;

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

545 type = AVMEDIA_TYPE_AUDIO;

546 if (m->sofdec > 0) {

547 codec_id = AV_CODEC_ID_ADPCM_ADX;

548 // Auto-detect AC-3

549 request_probe = 50;

550 } else {

551 codec_id = AV_CODEC_ID_MP2;

552 }

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

554 type = AVMEDIA_TYPE_AUDIO;

555 codec_id = AV_CODEC_ID_AC3;

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

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

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

559 type = AVMEDIA_TYPE_AUDIO;

560 codec_id = AV_CODEC_ID_DTS;

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

562 type = AVMEDIA_TYPE_AUDIO;

563 if (lpcm_header_len == 6) {

564 codec_id = AV_CODEC_ID_MLP;

565 } else {

566 codec_id = AV_CODEC_ID_PCM_DVD;

567 }

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

569 type = AVMEDIA_TYPE_AUDIO;

570 codec_id = AV_CODEC_ID_TRUEHD;

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

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

573 type = AVMEDIA_TYPE_AUDIO;

574 codec_id = AV_CODEC_ID_AC3;

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

576 type = AVMEDIA_TYPE_SUBTITLE;

577 codec_id = AV_CODEC_ID_DVD_SUBTITLE;

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

579 type = AVMEDIA_TYPE_VIDEO;

580 codec_id = AV_CODEC_ID_VC1;

581 } else {

582 skip:

583 /* skip packet */

584 avio_skip(s->pb, len);

585 goto redo;

586 }

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

588 st = avformat_new_stream(s, NULL);

589 if (!st)

590 goto skip;

591 st->id = startcode;

592 st->codec->codec_type = type;

593 st->codec->codec_id = codec_id;

594 if (st->codec->codec_id == AV_CODEC_ID_PCM_MULAW) {

595 st->codec->channels = 1;

596 st->codec->channel_layout = AV_CH_LAYOUT_MONO;

597 st->codec->sample_rate = 8000;

598 }

599 st->request_probe = request_probe;

600 st->need_parsing = AVSTREAM_PARSE_FULL;

601

602 found:

603 if (st->discard >= AVDISCARD_ALL)

604 goto skip;

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

606 if (lpcm_header_len == 6 && st->codec->codec_id == AV_CODEC_ID_MLP) {

607 if (len < 6)

608 goto skip;

609 avio_skip(s->pb, 6);

610 len -=6;

611 }

612 }

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

614

615 pkt->pts = pts;

616 pkt->dts = dts;

617 pkt->pos = dummy_pos;

618 pkt->stream_index = st->index;

619 av_dlog(s, "%d: pts=%0.3f dts=%0.3f size=%d\n",

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

621 pkt->size);

622

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

624 }

625

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

627 int64_t *ppos, int64_t pos_limit)

628 {

629 int len, startcode;

630 int64_t pos, pts, dts;

631

632 pos = *ppos;

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

634 return AV_NOPTS_VALUE;

635

636 for (;;) {

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

638 if (len < 0) {

639 av_dlog(s, "none (ret=%d)\n", len);

640 return AV_NOPTS_VALUE;

641 }

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

643 dts != AV_NOPTS_VALUE) {

644 break;

645 }

646 avio_skip(s->pb, len);

647 }

648 av_dlog(s, "pos=0x%"PRIx64" dts=0x%"PRIx64" %0.3f\n",

649 pos, dts, dts / 90000.0);

650 *ppos = pos;

651 return dts;

652 }

653

654 AVInputFormat ff_mpegps_demuxer = {

655 .name = "mpeg",

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

657 .priv_data_size = sizeof(MpegDemuxContext),

658 .read_probe = mpegps_probe,

659 .read_header = mpegps_read_header,

660 .read_packet = mpegps_read_packet,

661 .read_timestamp = mpegps_read_dts,

662 .flags = AVFMT_SHOW_IDS | AVFMT_TS_DISCONT,

663 };

664

665 #if CONFIG_VOBSUB_DEMUXER

666

667 #define REF_STRING "# VobSub index file,"

668 #define MAX_LINE_SIZE 2048

669

670 static int vobsub_probe(AVProbeData *p)

671 {

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

673 return AVPROBE_SCORE_MAX;

674 return 0;

675 }

676

677 static int vobsub_read_header(AVFormatContext *s)

678 {

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

680 MpegDemuxContext *vobsub = s->priv_data;

681 char *sub_name = NULL;

682 size_t fname_len;

683 char *ext, *header_str;

684 AVBPrint header;

685 int64_t delay = 0;

686 AVStream *st = NULL;

687 int stream_id = -1;

688 char id[64] = {0};

689 char alt[MAX_LINE_SIZE] = {0};

690 AVInputFormat *iformat;

691

692 sub_name = av_strdup(s->filename);

693 fname_len = strlen(sub_name);

694 ext = sub_name - 3 + fname_len;

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

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

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

698 ret = AVERROR_INVALIDDATA;

699 goto end;

700 }

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

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

703

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

705 ret = AVERROR_DEMUXER_NOT_FOUND;

706 goto end;

707 }

708

709 vobsub->sub_ctx = avformat_alloc_context();

710 if (!vobsub->sub_ctx) {

711 ret = AVERROR(ENOMEM);

712 goto end;

713 }

714

715 if ((ret = ff_copy_whitelists(vobsub->sub_ctx, s)) < 0)

716 goto end;

717

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

719 if (ret < 0) {

720 av_log(s, AV_LOG_ERROR, "Unable to open %s as MPEG subtitles\n", sub_name);

721 goto end;

722 }

723

724 av_bprint_init(&header, 0, AV_BPRINT_SIZE_UNLIMITED);

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

726 char line[MAX_LINE_SIZE];

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

728

729 if (!len)

730 break;

731

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

733

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

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

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

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

738 strcpy(id, "und");

739 stream_id = 0;

740 }

741

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

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

744 ret = AVERROR(EINVAL);

745 goto end;

746 }

747

748 header_parsed = 1;

749 alt[0] = '0円';

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

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

752

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

754

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

756 AVPacket *sub;

757 int hh, mm, ss, ms;

758 int64_t pos, timestamp;

759 const char *p = line + 10;

760

761 if (stream_id == -1) {

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

763 ret = AVERROR_INVALIDDATA;

764 goto end;

765 }

766

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

768 st = avformat_new_stream(s, NULL);

769 if (!st) {

770 ret = AVERROR(ENOMEM);

771 goto end;

772 }

773 st->id = stream_id;

774 st->codec->codec_type = AVMEDIA_TYPE_SUBTITLE;

775 st->codec->codec_id = AV_CODEC_ID_DVD_SUBTITLE;

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

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

778 if (alt[0])

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

780 }

781

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

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

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

785 "abort parsing\n", line);

786 ret = AVERROR_INVALIDDATA;

787 goto end;

788 }

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

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

791

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

793 if (!sub) {

794 ret = AVERROR(ENOMEM);

795 goto end;

796 }

797 sub->pos = pos;

798 sub->pts = timestamp;

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

800

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

802 const char *p = line + 4;

803

804 while (*p == ' ')

805 p++;

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

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

808 header_parsed = 1;

809

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

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

812 const char *p = line + 6;

813

814 while (*p == ' ')

815 p++;

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

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

818 p++;

819 }

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

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

822

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

824 const char *p = line + 8;

825

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

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

828

829 } else if (!header_parsed) {

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

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

832 }

833 }

834

835 if (langidx < s->nb_streams)

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

837

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

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

840 ff_subtitles_queue_finalize(&vobsub->q[i]);

841 }

842

843 if (!av_bprint_is_complete(&header)) {

844 av_bprint_finalize(&header, NULL);

845 ret = AVERROR(ENOMEM);

846 goto end;

847 }

848 av_bprint_finalize(&header, &header_str);

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

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

851 sub_st->codec->extradata = av_strdup(header_str);

852 sub_st->codec->extradata_size = header.len;

853 }

854 av_free(header_str);

855

856 end:

857 av_free(sub_name);

858 return ret;

859 }

860

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

862 {

863 MpegDemuxContext *vobsub = s->priv_data;

864 FFDemuxSubtitlesQueue *q;

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

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

867 AVPacket idx_pkt;

868

869 int64_t min_ts = INT64_MAX;

870 int sid = 0;

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

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

873 int64_t ts;

874 av_assert0(tmpq->nb_subs);

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

876 if (ts < min_ts) {

877 min_ts = ts;

878 sid = i;

879 }

880 }

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

882 ret = ff_subtitles_queue_read_packet(q, &idx_pkt);

883 if (ret < 0)

884 return ret;

885

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

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

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

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

890 } else {

891 int64_t fsize = avio_size(pb);

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

893 }

894

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

896

897 av_init_packet(pkt);

898 pkt->size = 0;

899 pkt->data = NULL;

900

901 do {

902 int n, to_read, startcode;

903 int64_t pts, dts;

904 int64_t old_pos = avio_tell(pb), new_pos;

905 int pkt_size;

906

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

908 if (ret < 0) {

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

910 break;

911 goto fail;

912 }

913 to_read = ret & 0xffff;

914 new_pos = avio_tell(pb);

915 pkt_size = ret + (new_pos - old_pos);

916

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

918 if (total_read + pkt_size > psize)

919 break;

920 total_read += pkt_size;

921

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

923 if ((startcode & 0x1f) != idx_pkt.stream_index)

924 break;

925

926 ret = av_grow_packet(pkt, to_read);

927 if (ret < 0)

928 goto fail;

929

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

931 if (n < to_read)

932 pkt->size -= to_read - n;

933 } while (total_read < psize);

934

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

936 pkt->pos = idx_pkt.pos;

937 pkt->stream_index = idx_pkt.stream_index;

938

939 av_free_packet(&idx_pkt);

940 return 0;

941

942 fail:

943 av_free_packet(pkt);

944 av_free_packet(&idx_pkt);

945 return ret;

946 }

947

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

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

950 {

951 MpegDemuxContext *vobsub = s->priv_data;

952

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

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

955 * like in avformat_seek_file(). */

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

957 int i, ret = 0;

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

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

960 min_ts = av_rescale_rnd(min_ts, time_base.den,

961 time_base.num * (int64_t)AV_TIME_BASE,

962 AV_ROUND_UP | AV_ROUND_PASS_MINMAX);

963 max_ts = av_rescale_rnd(max_ts, time_base.den,

964 time_base.num * (int64_t)AV_TIME_BASE,

965 AV_ROUND_DOWN | AV_ROUND_PASS_MINMAX);

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

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

968 min_ts, ts, max_ts, flags);

969 if (r < 0)

970 ret = r;

971 }

972 return ret;

973 }

974

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

976 stream_index = 0;

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

978 min_ts, ts, max_ts, flags);

979 }

980

981 static int vobsub_read_close(AVFormatContext *s)

982 {

983 int i;

984 MpegDemuxContext *vobsub = s->priv_data;

985

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

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

988 if (vobsub->sub_ctx)

989 avformat_close_input(&vobsub->sub_ctx);

990 return 0;

991 }

992

993 AVInputFormat ff_vobsub_demuxer = {

994 .name = "vobsub",

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

996 .priv_data_size = sizeof(MpegDemuxContext),

997 .read_probe = vobsub_probe,

998 .read_header = vobsub_read_header,

999 .read_packet = vobsub_read_packet,

1000 .read_seek2 = vobsub_read_seek,

1001 .read_close = vobsub_read_close,

1002 .flags = AVFMT_SHOW_IDS,

1003 .extensions = "idx",

1004 };

1005 #endif

Generated on Sun Mar 8 2015 02:35:10 for FFmpeg by doxygen 1.8.2