1/* 2 * MPEG-1/2 demuxer 3 * Copyright (c) 2000, 2001, 2002 Fabrice Bellard 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 */ 21 22#include "config_components.h" 23 24#include "libavutil/channel_layout.h" 25#include "avformat.h" 26#include "avio_internal.h" 27#include "demux.h" 28#include "internal.h" 29#include "mpeg.h" 30 31/*********************************************/ 32/* demux code */ 33 34#define MAX_SYNC_SIZE 100000 35 36static int check_pes(const uint8_t *p, const uint8_t *end) 37{ 38 int pes1; 39 int pes2 = (p[3] & 0xC0) == 0x80 && 40 (p[4] & 0xC0) != 0x40 && 41 ((p[4] & 0xC0) == 0x00 || 42 (p[4] & 0xC0) >> 2 == (p[6] & 0xF0)); 43 44 for (p += 3; p < end && *p == 0xFF; p++) ; 45 if ((*p & 0xC0) == 0x40) 46 p += 2; 47 48 if ((*p & 0xF0) == 0x20) 49 pes1 = p[0] & p[2] & p[4] & 1; 50 else if ((*p & 0xF0) == 0x30) 51 pes1 = p[0] & p[2] & p[4] & p[5] & p[7] & p[9] & 1; 52 else 53 pes1 = *p == 0x0F; 54 55 return pes1 || pes2; 56} 57 58static int check_pack_header(const uint8_t *buf) 59{ 60 return (buf[1] & 0xC0) == 0x40 || (buf[1] & 0xF0) == 0x20; 61} 62 63static int mpegps_probe(const AVProbeData *p) 64{ 65 uint32_t code = -1; 66 int i; 67 int sys = 0, pspack = 0, priv1 = 0, vid = 0; 68 int audio = 0, invalid = 0, score = 0; 69 int endpes = 0; 70 71 for (i = 0; i < p->buf_size; i++) { 72 code = (code << 8) + p->buf[i]; 73 if ((code & 0xffffff00) == 0x100) { 74 int len = p->buf[i + 1] << 8 | p->buf[i + 2]; 75 int pes = endpes <= i && check_pes(p->buf + i, p->buf + p->buf_size); 76 int pack = check_pack_header(p->buf + i); 77 78 if (code == SYSTEM_HEADER_START_CODE) 79 sys++; 80 else if (code == PACK_START_CODE && pack) 81 pspack++; 82 else if ((code & 0xf0) == VIDEO_ID && pes) { 83 endpes = i + len; 84 vid++; 85 } 86 // skip pes payload to avoid start code emulation for private 87 // and audio streams 88 else if ((code & 0xe0) == AUDIO_ID && pes) {audio++; i+=len;} 89 else if (code == PRIVATE_STREAM_1 && pes) {priv1++; i+=len;} 90 else if (code == 0x1fd && pes) vid++; //VC1 91 92 else if ((code & 0xf0) == VIDEO_ID && !pes) invalid++; 93 else if ((code & 0xe0) == AUDIO_ID && !pes) invalid++; 94 else if (code == PRIVATE_STREAM_1 && !pes) invalid++; 95 } 96 } 97 98 if (vid + audio > invalid + 1) /* invalid VDR files nd short PES streams */ 99 score = AVPROBE_SCORE_EXTENSION / 2; 100 101// av_log(NULL, AV_LOG_ERROR, "vid:%d aud:%d sys:%d pspack:%d invalid:%d size:%d \n", 102// vid, audio, sys, pspack, invalid, p->buf_size); 103 104 if (sys > invalid && sys * 9 <= pspack * 10) 105 return (audio > 12 || vid > 3 || pspack > 2) ? AVPROBE_SCORE_EXTENSION + 2 106 : AVPROBE_SCORE_EXTENSION / 2 + (audio + vid + pspack > 1); // 1 more than mp3 107 if (pspack > invalid && (priv1 + vid + audio) * 10 >= pspack * 9) 108 return pspack > 2 ? AVPROBE_SCORE_EXTENSION + 2 109 : AVPROBE_SCORE_EXTENSION / 2; // 1 more than .mpg 110 if ((!!vid ^ !!audio) && (audio > 4 || vid > 1) && !sys && 111 !pspack && p->buf_size > 2048 && vid + audio > invalid) /* PES stream */ 112 return (audio > 12 || vid > 6 + 2 * invalid) ? AVPROBE_SCORE_EXTENSION + 2 113 : AVPROBE_SCORE_EXTENSION / 2; 114 115 // 02-Penguin.flac has sys:0 priv1:0 pspack:0 vid:0 audio:1 116 // mp3_misidentified_2.mp3 has sys:0 priv1:0 pspack:0 vid:0 audio:6 117 // Have\ Yourself\ a\ Merry\ Little\ Christmas.mp3 0 0 0 5 0 1 len:21618 118 return score; 119} 120 121typedef struct MpegDemuxContext { 122 int32_t header_state; 123 unsigned char psm_es_type[256]; 124 int sofdec; 125 int dvd; 126 int imkh_cctv; 127 int raw_ac3; 128} MpegDemuxContext; 129 130static int mpegps_read_header(AVFormatContext *s) 131{ 132 MpegDemuxContext *m = s->priv_data; 133 char buffer[7] = { 0 }; 134 int64_t last_pos = avio_tell(s->pb); 135 136 m->header_state = 0xff; 137 s->ctx_flags |= AVFMTCTX_NOHEADER; 138 139 avio_get_str(s->pb, 6, buffer, sizeof(buffer)); 140 if (!memcmp("IMKH", buffer, 4)) { 141 m->imkh_cctv = 1; 142 } else if (!memcmp("Sofdec", buffer, 6)) { 143 m->sofdec = 1; 144 } else 145 avio_seek(s->pb, last_pos, SEEK_SET); 146 147 /* no need to do more */ 148 return 0; 149} 150 151static int64_t get_pts(AVIOContext *pb, int c) 152{ 153 uint8_t buf[5]; 154 int ret; 155 156 buf[0] = c < 0 ? avio_r8(pb) : c; 157 ret = avio_read(pb, buf + 1, 4); 158 if (ret < 4) 159 return AV_NOPTS_VALUE; 160 161 return ff_parse_pes_pts(buf); 162} 163 164static int find_next_start_code(AVIOContext *pb, int *size_ptr, 165 int32_t *header_state) 166{ 167 unsigned int state, v; 168 int val, n; 169 170 state = *header_state; 171 n = *size_ptr; 172 while (n > 0) { 173 if (avio_feof(pb)) 174 break; 175 v = avio_r8(pb); 176 n--; 177 if (state == 0x000001) { 178 state = ((state << 8) | v) & 0xffffff; 179 val = state; 180 goto found; 181 } 182 state = ((state << 8) | v) & 0xffffff; 183 } 184 val = -1; 185 186found: 187 *header_state = state; 188 *size_ptr = n; 189 return val; 190} 191 192/** 193 * Extract stream types from a program stream map 194 * According to ISO/IEC 13818-1 ('MPEG-2 Systems') table 2-35 195 * 196 * @return number of bytes occupied by PSM in the bitstream 197 */ 198static long mpegps_psm_parse(MpegDemuxContext *m, AVIOContext *pb) 199{ 200 int psm_length, ps_info_length, es_map_length; 201 202 psm_length = avio_rb16(pb); 203 avio_r8(pb); 204 avio_r8(pb); 205 ps_info_length = avio_rb16(pb); 206 207 /* skip program_stream_info */ 208 avio_skip(pb, ps_info_length); 209 /*es_map_length = */avio_rb16(pb); 210 /* Ignore es_map_length, trust psm_length */ 211 es_map_length = psm_length - ps_info_length - 10; 212 213 /* at least one es available? */ 214 while (es_map_length >= 4) { 215 unsigned char type = avio_r8(pb); 216 unsigned char es_id = avio_r8(pb); 217 uint16_t es_info_length = avio_rb16(pb); 218 219 /* remember mapping from stream id to stream type */ 220 m->psm_es_type[es_id] = type; 221 /* skip program_stream_info */ 222 avio_skip(pb, es_info_length); 223 es_map_length -= 4 + es_info_length; 224 } 225 avio_rb32(pb); /* crc32 */ 226 return 2 + psm_length; 227} 228 229/* read the next PES header. Return its position in ppos 230 * (if not NULL), and its start code, pts and dts. 231 */ 232static int mpegps_read_pes_header(AVFormatContext *s, 233 int64_t *ppos, int *pstart_code, 234 int64_t *ppts, int64_t *pdts) 235{ 236 MpegDemuxContext *m = s->priv_data; 237 int len, size, startcode, c, flags, header_len; 238 int pes_ext, ext2_len, id_ext, skip; 239 int64_t pts, dts; 240 int64_t last_sync = avio_tell(s->pb); 241 242error_redo: 243 avio_seek(s->pb, last_sync, SEEK_SET); 244redo: 245 /* next start code (should be immediately after) */ 246 m->header_state = 0xff; 247 size = MAX_SYNC_SIZE; 248 startcode = find_next_start_code(s->pb, &size, &m->header_state); 249 last_sync = avio_tell(s->pb); 250 if (startcode < 0) { 251 if (avio_feof(s->pb)) 252 return AVERROR_EOF; 253 // FIXME we should remember header_state 254 return FFERROR_REDO; 255 } 256 257 if (startcode == PACK_START_CODE) 258 goto redo; 259 if (startcode == SYSTEM_HEADER_START_CODE) 260 goto redo; 261 if (startcode == PADDING_STREAM) { 262 avio_skip(s->pb, avio_rb16(s->pb)); 263 goto redo; 264 } 265 if (startcode == PRIVATE_STREAM_2) { 266 if (!m->sofdec) { 267 /* Need to detect whether this from a DVD or a 'Sofdec' stream */ 268 int len = avio_rb16(s->pb); 269 int bytesread = 0; 270 uint8_t *ps2buf = av_malloc(len); 271 272 if (ps2buf) { 273 bytesread = avio_read(s->pb, ps2buf, len); 274 275 if (bytesread != len) { 276 avio_skip(s->pb, len - bytesread); 277 } else { 278 uint8_t *p = 0; 279 if (len >= 6) 280 p = memchr(ps2buf, 'S', len - 5); 281 282 if (p) 283 m->sofdec = !memcmp(p+1, "ofdec", 5); 284 285 m->sofdec -= !m->sofdec; 286 287 if (m->sofdec < 0) { 288 if (len == 980 && ps2buf[0] == 0) { 289 /* PCI structure? */ 290 uint32_t startpts = AV_RB32(ps2buf + 0x0d); 291 uint32_t endpts = AV_RB32(ps2buf + 0x11); 292 uint8_t hours = ((ps2buf[0x19] >> 4) * 10) + (ps2buf[0x19] & 0x0f); 293 uint8_t mins = ((ps2buf[0x1a] >> 4) * 10) + (ps2buf[0x1a] & 0x0f); 294 uint8_t secs = ((ps2buf[0x1b] >> 4) * 10) + (ps2buf[0x1b] & 0x0f); 295 296 m->dvd = (hours <= 23 && 297 mins <= 59 && 298 secs <= 59 && 299 (ps2buf[0x19] & 0x0f) < 10 && 300 (ps2buf[0x1a] & 0x0f) < 10 && 301 (ps2buf[0x1b] & 0x0f) < 10 && 302 endpts >= startpts); 303 } else if (len == 1018 && ps2buf[0] == 1) { 304 /* DSI structure? */ 305 uint8_t hours = ((ps2buf[0x1d] >> 4) * 10) + (ps2buf[0x1d] & 0x0f); 306 uint8_t mins = ((ps2buf[0x1e] >> 4) * 10) + (ps2buf[0x1e] & 0x0f); 307 uint8_t secs = ((ps2buf[0x1f] >> 4) * 10) + (ps2buf[0x1f] & 0x0f); 308 309 m->dvd = (hours <= 23 && 310 mins <= 59 && 311 secs <= 59 && 312 (ps2buf[0x1d] & 0x0f) < 10 && 313 (ps2buf[0x1e] & 0x0f) < 10 && 314 (ps2buf[0x1f] & 0x0f) < 10); 315 } 316 } 317 } 318 319 av_free(ps2buf); 320 321 /* If this isn't a DVD packet or no memory 322 * could be allocated, just ignore it. 323 * If we did, move back to the start of the 324 * packet (plus 'length' field) */ 325 if (!m->dvd || avio_skip(s->pb, -(len + 2)) < 0) { 326 /* Skip back failed. 327 * This packet will be lost but that can't be helped 328 * if we can't skip back 329 */ 330 goto redo; 331 } 332 } else { 333 /* No memory */ 334 avio_skip(s->pb, len); 335 goto redo; 336 } 337 } else if (!m->dvd) { 338 int len = avio_rb16(s->pb); 339 avio_skip(s->pb, len); 340 goto redo; 341 } 342 } 343 if (startcode == PROGRAM_STREAM_MAP) { 344 mpegps_psm_parse(m, s->pb); 345 goto redo; 346 } 347 348 /* find matching stream */ 349 if (!((startcode >= 0x1c0 && startcode <= 0x1df) || 350 (startcode >= 0x1e0 && startcode <= 0x1ef) || 351 (startcode == 0x1bd) || 352 (startcode == PRIVATE_STREAM_2) || 353 (startcode == 0x1fd))) 354 goto redo; 355 if (ppos) { 356 *ppos = avio_tell(s->pb) - 4; 357 } 358 len = avio_rb16(s->pb); 359 pts = 360 dts = AV_NOPTS_VALUE; 361 if (startcode != PRIVATE_STREAM_2) 362 { 363 /* stuffing */ 364 for (;;) { 365 if (len < 1) 366 goto error_redo; 367 c = avio_r8(s->pb); 368 len--; 369 /* XXX: for MPEG-1, should test only bit 7 */ 370 if (c != 0xff) 371 break; 372 } 373 if ((c & 0xc0) == 0x40) { 374 /* buffer scale & size */ 375 avio_r8(s->pb); 376 c = avio_r8(s->pb); 377 len -= 2; 378 } 379 if ((c & 0xe0) == 0x20) { 380 dts = 381 pts = get_pts(s->pb, c); 382 len -= 4; 383 if (c & 0x10) { 384 dts = get_pts(s->pb, -1); 385 len -= 5; 386 } 387 } else if ((c & 0xc0) == 0x80) { 388 /* mpeg 2 PES */ 389 flags = avio_r8(s->pb); 390 header_len = avio_r8(s->pb); 391 len -= 2; 392 if (header_len > len) 393 goto error_redo; 394 len -= header_len; 395 if (flags & 0x80) { 396 dts = pts = get_pts(s->pb, -1); 397 header_len -= 5; 398 if (flags & 0x40) { 399 dts = get_pts(s->pb, -1); 400 header_len -= 5; 401 } 402 } 403 if (flags & 0x3f && header_len == 0) { 404 flags &= 0xC0; 405 av_log(s, AV_LOG_WARNING, "Further flags set but no bytes left\n"); 406 } 407 if (flags & 0x01) { /* PES extension */ 408 pes_ext = avio_r8(s->pb); 409 header_len--; 410 /* Skip PES private data, program packet sequence counter 411 * and P-STD buffer */ 412 skip = (pes_ext >> 4) & 0xb; 413 skip += skip & 0x9; 414 if (pes_ext & 0x40 || skip > header_len) { 415 av_log(s, AV_LOG_WARNING, "pes_ext %X is invalid\n", pes_ext); 416 pes_ext = skip = 0; 417 } 418 avio_skip(s->pb, skip); 419 header_len -= skip; 420 421 if (pes_ext & 0x01) { /* PES extension 2 */ 422 ext2_len = avio_r8(s->pb); 423 header_len--; 424 if ((ext2_len & 0x7f) > 0) { 425 id_ext = avio_r8(s->pb); 426 if ((id_ext & 0x80) == 0) 427 startcode = ((startcode & 0xff) << 8) | id_ext; 428 header_len--; 429 } 430 } 431 } 432 if (header_len < 0) 433 goto error_redo; 434 avio_skip(s->pb, header_len); 435 } else if (c != 0xf) 436 goto redo; 437 } 438 439 if (startcode == PRIVATE_STREAM_1) { 440 int ret = ffio_ensure_seekback(s->pb, 2); 441 442 if (ret < 0) 443 return ret; 444 445 startcode = avio_r8(s->pb); 446 m->raw_ac3 = 0; 447 if (startcode == 0x0b) { 448 if (avio_r8(s->pb) == 0x77) { 449 startcode = 0x80; 450 m->raw_ac3 = 1; 451 avio_skip(s->pb, -2); 452 } else { 453 avio_skip(s->pb, -1); 454 } 455 } else { 456 len--; 457 } 458 } 459 if (len < 0) 460 goto error_redo; 461 if (dts != AV_NOPTS_VALUE && ppos) { 462 int i; 463 for (i = 0; i < s->nb_streams; i++) { 464 if (startcode == s->streams[i]->id && 465 (s->pb->seekable & AVIO_SEEKABLE_NORMAL) /* index useless on streams anyway */) { 466 ff_reduce_index(s, i); 467 av_add_index_entry(s->streams[i], *ppos, dts, 0, 0, 468 AVINDEX_KEYFRAME /* FIXME keyframe? */); 469 } 470 } 471 } 472 473 *pstart_code = startcode; 474 *ppts = pts; 475 *pdts = dts; 476 return len; 477} 478 479static int mpegps_read_packet(AVFormatContext *s, 480 AVPacket *pkt) 481{ 482 MpegDemuxContext *m = s->priv_data; 483 AVStream *st; 484 FFStream *sti; 485 int len, startcode, i, es_type, ret; 486 int pcm_dvd = 0; 487 int request_probe= 0; 488 enum AVCodecID codec_id = AV_CODEC_ID_NONE; 489 enum AVMediaType type; 490 int64_t pts, dts, dummy_pos; // dummy_pos is needed for the index building to work 491 492redo: 493 len = mpegps_read_pes_header(s, &dummy_pos, &startcode, &pts, &dts); 494 if (len < 0) 495 return len; 496 497 if (startcode >= 0x80 && startcode <= 0xcf) { 498 if (len < 4) 499 goto skip; 500 501 if (!m->raw_ac3) { 502 /* audio: skip header */ 503 avio_skip(s->pb, 3); 504 len -= 3; 505 if (startcode >= 0xb0 && startcode <= 0xbf) { 506 /* MLP/TrueHD audio has a 4-byte header */ 507 avio_r8(s->pb); 508 len--; 509 } else if (startcode >= 0xa0 && startcode <= 0xaf) { 510 ret = ffio_ensure_seekback(s->pb, 3); 511 if (ret < 0) 512 return ret; 513 pcm_dvd = (avio_rb24(s->pb) & 0xFF) == 0x80; 514 avio_skip(s->pb, -3); 515 } 516 } 517 } 518 519 /* now find stream */ 520 for (i = 0; i < s->nb_streams; i++) { 521 st = s->streams[i]; 522 if (st->id == startcode) 523 goto found; 524 } 525 526 es_type = m->psm_es_type[startcode & 0xff]; 527 if (es_type == STREAM_TYPE_VIDEO_MPEG1) { 528 codec_id = AV_CODEC_ID_MPEG2VIDEO; 529 type = AVMEDIA_TYPE_VIDEO; 530 } else if (es_type == STREAM_TYPE_VIDEO_MPEG2) { 531 codec_id = AV_CODEC_ID_MPEG2VIDEO; 532 type = AVMEDIA_TYPE_VIDEO; 533 } else if (es_type == STREAM_TYPE_AUDIO_MPEG1 || 534 es_type == STREAM_TYPE_AUDIO_MPEG2) { 535 codec_id = AV_CODEC_ID_MP3; 536 type = AVMEDIA_TYPE_AUDIO; 537 } else if (es_type == STREAM_TYPE_AUDIO_AAC) { 538 codec_id = AV_CODEC_ID_AAC; 539 type = AVMEDIA_TYPE_AUDIO; 540 } else if (es_type == STREAM_TYPE_VIDEO_MPEG4) { 541 codec_id = AV_CODEC_ID_MPEG4; 542 type = AVMEDIA_TYPE_VIDEO; 543 } else if (es_type == STREAM_TYPE_VIDEO_H264) { 544 codec_id = AV_CODEC_ID_H264; 545 type = AVMEDIA_TYPE_VIDEO; 546 } else if (es_type == STREAM_TYPE_VIDEO_HEVC) { 547 codec_id = AV_CODEC_ID_HEVC; 548 type = AVMEDIA_TYPE_VIDEO; 549 } else if (es_type == STREAM_TYPE_AUDIO_AC3) { 550 codec_id = AV_CODEC_ID_AC3; 551 type = AVMEDIA_TYPE_AUDIO; 552 } else if (m->imkh_cctv && es_type == 0x91) { 553 codec_id = AV_CODEC_ID_PCM_MULAW; 554 type = AVMEDIA_TYPE_AUDIO; 555 } else if (startcode >= 0x1e0 && startcode <= 0x1ef) { 556 static const unsigned char avs_seqh[4] = { 0, 0, 1, 0xb0 }; 557 unsigned char buf[8]; 558 559 avio_read(s->pb, buf, 8); 560 avio_seek(s->pb, -8, SEEK_CUR); 561 if (!memcmp(buf, avs_seqh, 4) && (buf[6] != 0 || buf[7] != 1)) 562 codec_id = AV_CODEC_ID_CAVS; 563 else 564 request_probe= 1; 565 type = AVMEDIA_TYPE_VIDEO; 566 } else if (startcode == PRIVATE_STREAM_2) { 567 type = AVMEDIA_TYPE_DATA; 568 codec_id = AV_CODEC_ID_DVD_NAV; 569 } else if (startcode >= 0x1c0 && startcode <= 0x1df) { 570 type = AVMEDIA_TYPE_AUDIO; 571 if (m->sofdec > 0) { 572 codec_id = AV_CODEC_ID_ADPCM_ADX; 573 // Auto-detect AC-3 574 request_probe = 50; 575 } else if (m->imkh_cctv && startcode == 0x1c0 && len > 80) { 576 codec_id = AV_CODEC_ID_PCM_ALAW; 577 request_probe = 50; 578 } else { 579 codec_id = AV_CODEC_ID_MP2; 580 if (m->imkh_cctv) 581 request_probe = 25; 582 } 583 } else if (startcode >= 0x80 && startcode <= 0x87) { 584 type = AVMEDIA_TYPE_AUDIO; 585 codec_id = AV_CODEC_ID_AC3; 586 } else if ((startcode >= 0x88 && startcode <= 0x8f) || 587 (startcode >= 0x98 && startcode <= 0x9f)) { 588 /* 0x90 - 0x97 is reserved for SDDS in DVD specs */ 589 type = AVMEDIA_TYPE_AUDIO; 590 codec_id = AV_CODEC_ID_DTS; 591 } else if (startcode >= 0xa0 && startcode <= 0xaf) { 592 type = AVMEDIA_TYPE_AUDIO; 593 if (!pcm_dvd) { 594 codec_id = AV_CODEC_ID_MLP; 595 } else { 596 codec_id = AV_CODEC_ID_PCM_DVD; 597 } 598 } else if (startcode >= 0xb0 && startcode <= 0xbf) { 599 type = AVMEDIA_TYPE_AUDIO; 600 codec_id = AV_CODEC_ID_TRUEHD; 601 } else if (startcode >= 0xc0 && startcode <= 0xcf) { 602 /* Used for both AC-3 and E-AC-3 in EVOB files */ 603 type = AVMEDIA_TYPE_AUDIO; 604 codec_id = AV_CODEC_ID_AC3; 605 } else if (startcode >= 0x20 && startcode <= 0x3f) { 606 type = AVMEDIA_TYPE_SUBTITLE; 607 codec_id = AV_CODEC_ID_DVD_SUBTITLE; 608 } else if (startcode >= 0xfd55 && startcode <= 0xfd5f) { 609 type = AVMEDIA_TYPE_VIDEO; 610 codec_id = AV_CODEC_ID_VC1; 611 } else { 612skip: 613 /* skip packet */ 614 avio_skip(s->pb, len); 615 goto redo; 616 } 617 /* no stream found: add a new stream */ 618 st = avformat_new_stream(s, NULL); 619 if (!st) 620 goto skip; 621 sti = ffstream(st); 622 st->id = startcode; 623 st->codecpar->codec_type = type; 624 st->codecpar->codec_id = codec_id; 625 if ( st->codecpar->codec_id == AV_CODEC_ID_PCM_MULAW 626 || st->codecpar->codec_id == AV_CODEC_ID_PCM_ALAW) { 627 st->codecpar->ch_layout = (AVChannelLayout)AV_CHANNEL_LAYOUT_MONO; 628 st->codecpar->sample_rate = 8000; 629 } 630 sti->request_probe = request_probe; 631 sti->need_parsing = AVSTREAM_PARSE_FULL; 632 633found: 634 if (st->discard >= AVDISCARD_ALL) 635 goto skip; 636 if (startcode >= 0xa0 && startcode <= 0xaf) { 637 if (st->codecpar->codec_id == AV_CODEC_ID_MLP) { 638 if (len < 6) 639 goto skip; 640 avio_skip(s->pb, 6); 641 len -=6; 642 } 643 } 644 ret = av_get_packet(s->pb, pkt, len); 645 646 pkt->pts = pts; 647 pkt->dts = dts; 648 pkt->pos = dummy_pos; 649 pkt->stream_index = st->index; 650 651 if (s->debug & FF_FDEBUG_TS) 652 av_log(s, AV_LOG_DEBUG, "%d: pts=%0.3f dts=%0.3f size=%d\n", 653 pkt->stream_index, pkt->pts / 90000.0, pkt->dts / 90000.0, 654 pkt->size); 655 656 return (ret < 0) ? ret : 0; 657} 658 659static int64_t mpegps_read_dts(AVFormatContext *s, int stream_index, 660 int64_t *ppos, int64_t pos_limit) 661{ 662 int len, startcode; 663 int64_t pos, pts, dts; 664 665 pos = *ppos; 666 if (avio_seek(s->pb, pos, SEEK_SET) < 0) 667 return AV_NOPTS_VALUE; 668 669 for (;;) { 670 len = mpegps_read_pes_header(s, &pos, &startcode, &pts, &dts); 671 if (len < 0) { 672 if (s->debug & FF_FDEBUG_TS) 673 av_log(s, AV_LOG_DEBUG, "none (ret=%d)\n", len); 674 return AV_NOPTS_VALUE; 675 } 676 if (startcode == s->streams[stream_index]->id && 677 dts != AV_NOPTS_VALUE) { 678 break; 679 } 680 avio_skip(s->pb, len); 681 } 682 if (s->debug & FF_FDEBUG_TS) 683 av_log(s, AV_LOG_DEBUG, "pos=0x%"PRIx64" dts=0x%"PRIx64" %0.3f\n", 684 pos, dts, dts / 90000.0); 685 *ppos = pos; 686 return dts; 687} 688 689const AVInputFormat ff_mpegps_demuxer = { 690 .name = "mpeg", 691 .long_name = NULL_IF_CONFIG_SMALL("MPEG-PS (MPEG-2 Program Stream)"), 692 .priv_data_size = sizeof(MpegDemuxContext), 693 .read_probe = mpegps_probe, 694 .read_header = mpegps_read_header, 695 .read_packet = mpegps_read_packet, 696 .read_timestamp = mpegps_read_dts, 697 .flags = AVFMT_SHOW_IDS | AVFMT_TS_DISCONT, 698}; 699 700#if CONFIG_VOBSUB_DEMUXER 701 702#include "subtitles.h" 703#include "libavutil/avassert.h" 704#include "libavutil/bprint.h" 705#include "libavutil/opt.h" 706 707#define REF_STRING "# VobSub index file," 708#define MAX_LINE_SIZE 2048 709 710typedef struct VobSubDemuxContext { 711 const AVClass *class; 712 AVFormatContext *sub_ctx; 713 FFDemuxSubtitlesQueue q[32]; 714 char *sub_name; 715} VobSubDemuxContext; 716 717static int vobsub_probe(const AVProbeData *p) 718{ 719 if (!strncmp(p->buf, REF_STRING, sizeof(REF_STRING) - 1)) 720 return AVPROBE_SCORE_MAX; 721 return 0; 722} 723 724static int vobsub_read_close(AVFormatContext *s) 725{ 726 VobSubDemuxContext *vobsub = s->priv_data; 727 int i; 728 729 for (i = 0; i < s->nb_streams; i++) 730 ff_subtitles_queue_clean(&vobsub->q[i]); 731 avformat_close_input(&vobsub->sub_ctx); 732 return 0; 733} 734 735static int vobsub_read_header(AVFormatContext *s) 736{ 737 int i, ret = 0, header_parsed = 0, langidx = 0; 738 VobSubDemuxContext *vobsub = s->priv_data; 739 const AVInputFormat *iformat; 740 size_t fname_len; 741 AVBPrint header; 742 int64_t delay = 0; 743 AVStream *st = NULL; 744 int stream_id = -1; 745 char id[64] = {0}; 746 char alt[MAX_LINE_SIZE] = {0}; 747 748 if (!vobsub->sub_name) { 749 char *ext; 750 vobsub->sub_name = av_strdup(s->url); 751 if (!vobsub->sub_name) { 752 return AVERROR(ENOMEM); 753 } 754 755 fname_len = strlen(vobsub->sub_name); 756 ext = vobsub->sub_name - 3 + fname_len; 757 if (fname_len < 4 || *(ext - 1) != '.') { 758 av_log(s, AV_LOG_ERROR, "The input index filename is too short " 759 "to guess the associated .SUB file\n"); 760 return AVERROR_INVALIDDATA; 761 } 762 memcpy(ext, !strncmp(ext, "IDX", 3) ? "SUB" : "sub", 3); 763 av_log(s, AV_LOG_VERBOSE, "IDX/SUB: %s -> %s\n", s->url, vobsub->sub_name); 764 } 765 766 if (!(iformat = av_find_input_format("mpeg"))) { 767 return AVERROR_DEMUXER_NOT_FOUND; 768 } 769 770 vobsub->sub_ctx = avformat_alloc_context(); 771 if (!vobsub->sub_ctx) { 772 return AVERROR(ENOMEM); 773 } 774 775 if ((ret = ff_copy_whiteblacklists(vobsub->sub_ctx, s)) < 0) 776 return ret; 777 778 ret = avformat_open_input(&vobsub->sub_ctx, vobsub->sub_name, iformat, NULL); 779 if (ret < 0) { 780 av_log(s, AV_LOG_ERROR, "Unable to open %s as MPEG subtitles\n", vobsub->sub_name); 781 return ret; 782 } 783 784 av_bprint_init(&header, 0, INT_MAX - AV_INPUT_BUFFER_PADDING_SIZE); 785 786 while (!avio_feof(s->pb)) { 787 char line[MAX_LINE_SIZE]; 788 int len = ff_get_line(s->pb, line, sizeof(line)); 789 790 if (!len) 791 break; 792 793 line[strcspn(line, "\r\n")] = 0; 794 795 if (!strncmp(line, "id:", 3)) { 796 if (sscanf(line, "id: %63[^,], index: %u", id, &stream_id) != 2) { 797 av_log(s, AV_LOG_WARNING, "Unable to parse index line '%s', " 798 "assuming 'id: und, index: 0'\n", line); 799 strcpy(id, "und"); 800 stream_id = 0; 801 } 802 803 if (stream_id >= FF_ARRAY_ELEMS(vobsub->q)) { 804 av_log(s, AV_LOG_ERROR, "Maximum number of subtitles streams reached\n"); 805 ret = AVERROR(EINVAL); 806 goto end; 807 } 808 809 header_parsed = 1; 810 alt[0] = '\0'; 811 /* We do not create the stream immediately to avoid adding empty 812 * streams. See the following timestamp entry. */ 813 814 av_log(s, AV_LOG_DEBUG, "IDX stream[%d] id=%s\n", stream_id, id); 815 816 } else if (!strncmp(line, "timestamp:", 10)) { 817 AVPacket *sub; 818 int hh, mm, ss, ms; 819 int64_t pos, timestamp; 820 const char *p = line + 10; 821 822 if (stream_id == -1) { 823 av_log(s, AV_LOG_ERROR, "Timestamp declared before any stream\n"); 824 ret = AVERROR_INVALIDDATA; 825 goto end; 826 } 827 828 if (!st || st->id != stream_id) { 829 st = avformat_new_stream(s, NULL); 830 if (!st) { 831 ret = AVERROR(ENOMEM); 832 goto end; 833 } 834 st->id = stream_id; 835 st->codecpar->codec_type = AVMEDIA_TYPE_SUBTITLE; 836 st->codecpar->codec_id = AV_CODEC_ID_DVD_SUBTITLE; 837 avpriv_set_pts_info(st, 64, 1, 1000); 838 av_dict_set(&st->metadata, "language", id, 0); 839 if (alt[0]) 840 av_dict_set(&st->metadata, "title", alt, 0); 841 } 842 843 if (sscanf(p, "%02d:%02d:%02d:%03d, filepos: %"SCNx64, 844 &hh, &mm, &ss, &ms, &pos) != 5) { 845 av_log(s, AV_LOG_ERROR, "Unable to parse timestamp line '%s', " 846 "abort parsing\n", line); 847 ret = AVERROR_INVALIDDATA; 848 goto end; 849 } 850 timestamp = (hh*3600LL + mm*60LL + ss) * 1000LL + ms + delay; 851 timestamp = av_rescale_q(timestamp, av_make_q(1, 1000), st->time_base); 852 853 sub = ff_subtitles_queue_insert(&vobsub->q[s->nb_streams - 1], "", 0, 0); 854 if (!sub) { 855 ret = AVERROR(ENOMEM); 856 goto end; 857 } 858 sub->pos = pos; 859 sub->pts = timestamp; 860 sub->stream_index = s->nb_streams - 1; 861 862 } else if (!strncmp(line, "alt:", 4)) { 863 const char *p = line + 4; 864 865 while (*p == ' ') 866 p++; 867 av_log(s, AV_LOG_DEBUG, "IDX stream[%d] name=%s\n", stream_id, p); 868 av_strlcpy(alt, p, sizeof(alt)); 869 header_parsed = 1; 870 871 } else if (!strncmp(line, "delay:", 6)) { 872 int sign = 1, hh = 0, mm = 0, ss = 0, ms = 0; 873 const char *p = line + 6; 874 875 while (*p == ' ') 876 p++; 877 if (*p == '-' || *p == '+') { 878 sign = *p == '-' ? -1 : 1; 879 p++; 880 } 881 sscanf(p, "%d:%d:%d:%d", &hh, &mm, &ss, &ms); 882 delay = ((hh*3600LL + mm*60LL + ss) * 1000LL + ms) * sign; 883 884 } else if (!strncmp(line, "langidx:", 8)) { 885 const char *p = line + 8; 886 887 if (sscanf(p, "%d", &langidx) != 1) 888 av_log(s, AV_LOG_ERROR, "Invalid langidx specified\n"); 889 890 } else if (!header_parsed) { 891 if (line[0] && line[0] != '#') 892 av_bprintf(&header, "%s\n", line); 893 } 894 } 895 896 if (langidx < s->nb_streams) 897 s->streams[langidx]->disposition |= AV_DISPOSITION_DEFAULT; 898 899 for (i = 0; i < s->nb_streams; i++) { 900 vobsub->q[i].sort = SUB_SORT_POS_TS; 901 vobsub->q[i].keep_duplicates = 1; 902 ff_subtitles_queue_finalize(s, &vobsub->q[i]); 903 } 904 905 if (!av_bprint_is_complete(&header)) { 906 ret = AVERROR(ENOMEM); 907 goto end; 908 } 909 for (i = 0; i < s->nb_streams; i++) { 910 AVCodecParameters *par = s->streams[i]->codecpar; 911 ret = ff_alloc_extradata(par, header.len); 912 if (ret < 0) { 913 goto end; 914 } 915 memcpy(par->extradata, header.str, header.len); 916 } 917end: 918 av_bprint_finalize(&header, NULL); 919 return ret; 920} 921 922static int vobsub_read_packet(AVFormatContext *s, AVPacket *pkt) 923{ 924 VobSubDemuxContext *vobsub = s->priv_data; 925 FFDemuxSubtitlesQueue *q; 926 AVIOContext *pb = vobsub->sub_ctx->pb; 927 int ret, psize, total_read = 0, i; 928 929 int64_t min_ts = INT64_MAX; 930 int sid = 0; 931 for (i = 0; i < s->nb_streams; i++) { 932 FFDemuxSubtitlesQueue *tmpq = &vobsub->q[i]; 933 int64_t ts; 934 av_assert0(tmpq->nb_subs); 935 936 if (tmpq->current_sub_idx >= tmpq->nb_subs) 937 continue; 938 939 ts = tmpq->subs[tmpq->current_sub_idx]->pts; 940 if (ts < min_ts) { 941 min_ts = ts; 942 sid = i; 943 } 944 } 945 q = &vobsub->q[sid]; 946 /* The returned packet will have size zero, 947 * so that it can be directly used with av_grow_packet. */ 948 ret = ff_subtitles_queue_read_packet(q, pkt); 949 if (ret < 0) 950 return ret; 951 952 /* compute maximum packet size using the next packet position. This is 953 * useful when the len in the header is non-sense */ 954 if (q->current_sub_idx < q->nb_subs) { 955 psize = q->subs[q->current_sub_idx]->pos - pkt->pos; 956 } else { 957 int64_t fsize = avio_size(pb); 958 psize = fsize < 0 ? 0xffff : fsize - pkt->pos; 959 } 960 961 avio_seek(pb, pkt->pos, SEEK_SET); 962 963 do { 964 int n, to_read, startcode; 965 int64_t pts, dts; 966 int64_t old_pos = avio_tell(pb), new_pos; 967 int pkt_size; 968 969 ret = mpegps_read_pes_header(vobsub->sub_ctx, NULL, &startcode, &pts, &dts); 970 if (ret < 0) { 971 if (pkt->size) // raise packet even if incomplete 972 break; 973 return ret; 974 } 975 to_read = ret & 0xffff; 976 new_pos = avio_tell(pb); 977 pkt_size = ret + (new_pos - old_pos); 978 979 /* this prevents reads above the current packet */ 980 if (total_read + pkt_size > psize) 981 break; 982 total_read += pkt_size; 983 984 /* the current chunk doesn't match the stream index (unlikely) */ 985 if ((startcode & 0x1f) != s->streams[pkt->stream_index]->id) 986 break; 987 988 ret = av_grow_packet(pkt, to_read); 989 if (ret < 0) 990 return ret; 991 992 n = avio_read(pb, pkt->data + (pkt->size - to_read), to_read); 993 if (n < to_read) 994 pkt->size -= to_read - n; 995 } while (total_read < psize); 996 997 return 0; 998} 999 1000static int vobsub_read_seek(AVFormatContext *s, int stream_index, 1001 int64_t min_ts, int64_t ts, int64_t max_ts, int flags) 1002{ 1003 VobSubDemuxContext *vobsub = s->priv_data; 1004 1005 /* Rescale requested timestamps based on the first stream (timebase is the 1006 * same for all subtitles stream within a .idx/.sub). Rescaling is done just 1007 * like in avformat_seek_file(). */ 1008 if (stream_index == -1 && s->nb_streams != 1) { 1009 int i, ret = 0; 1010 AVRational time_base = s->streams[0]->time_base; 1011 ts = av_rescale_q(ts, AV_TIME_BASE_Q, time_base); 1012 min_ts = av_rescale_rnd(min_ts, time_base.den, 1013 time_base.num * (int64_t)AV_TIME_BASE, 1014 AV_ROUND_UP | AV_ROUND_PASS_MINMAX); 1015 max_ts = av_rescale_rnd(max_ts, time_base.den, 1016 time_base.num * (int64_t)AV_TIME_BASE, 1017 AV_ROUND_DOWN | AV_ROUND_PASS_MINMAX); 1018 for (i = 0; i < s->nb_streams; i++) { 1019 int r = ff_subtitles_queue_seek(&vobsub->q[i], s, stream_index, 1020 min_ts, ts, max_ts, flags); 1021 if (r < 0) 1022 ret = r; 1023 } 1024 return ret; 1025 } 1026 1027 if (stream_index == -1) // only 1 stream 1028 stream_index = 0; 1029 return ff_subtitles_queue_seek(&vobsub->q[stream_index], s, stream_index, 1030 min_ts, ts, max_ts, flags); 1031} 1032 1033static const AVOption options[] = { 1034 { "sub_name", "URI for .sub file", offsetof(VobSubDemuxContext, sub_name), AV_OPT_TYPE_STRING, { .str = NULL }, 0, 0, AV_OPT_FLAG_DECODING_PARAM }, 1035 { NULL } 1036}; 1037 1038static 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 1045const AVInputFormat ff_vobsub_demuxer = { 1046 .name = "vobsub", 1047 .long_name = NULL_IF_CONFIG_SMALL("VobSub subtitle format"), 1048 .priv_data_size = sizeof(VobSubDemuxContext), 1049 .flags_internal = FF_FMT_INIT_CLEANUP, 1050 .read_probe = vobsub_probe, 1051 .read_header = vobsub_read_header, 1052 .read_packet = vobsub_read_packet, 1053 .read_seek2 = vobsub_read_seek, 1054 .read_close = vobsub_read_close, 1055 .flags = AVFMT_SHOW_IDS, 1056 .extensions = "idx", 1057 .priv_class = &vobsub_demuxer_class, 1058}; 1059#endif 1060