de6d9b64 |
/* |
2abe5a01 |
* MPEG1/2 demuxer |
406792e7 |
* Copyright (c) 2000, 2001, 2002 Fabrice Bellard |
de6d9b64 |
* |
b78e7197 |
* This file is part of FFmpeg.
*
* FFmpeg is free software; you can redistribute it and/or |
19720f15 |
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either |
b78e7197 |
* version 2.1 of the License, or (at your option) any later version. |
de6d9b64 |
* |
b78e7197 |
* FFmpeg is distributed in the hope that it will be useful, |
de6d9b64 |
* but WITHOUT ANY WARRANTY; without even the implied warranty of |
19720f15 |
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details. |
de6d9b64 |
* |
19720f15 |
* You should have received a copy of the GNU Lesser General Public |
b78e7197 |
* License along with FFmpeg; if not, write to the Free Software |
5509bffa |
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA |
de6d9b64 |
*/ |
2abe5a01 |
|
de6d9b64 |
#include "avformat.h" |
f8194672 |
#include "internal.h" |
2abe5a01 |
#include "mpeg.h" |
de6d9b64 |
|
710c4baf |
#if CONFIG_VOBSUB_DEMUXER
# include "subtitles.h"
# include "libavutil/bprint.h"
#endif
|
b754978a |
#undef NDEBUG
#include <assert.h>
|
de6d9b64 |
/*********************************************/
/* demux code */
#define MAX_SYNC_SIZE 100000
|
c3cb3389 |
static int check_pes(const uint8_t *p, const uint8_t *end){ |
c6dcd0d7 |
int pes1;
int pes2= (p[3] & 0xC0) == 0x80
&& (p[4] & 0xC0) != 0x40
&&((p[4] & 0xC0) == 0x00 || (p[4]&0xC0)>>2 == (p[6]&0xF0));
for(p+=3; p<end && *p == 0xFF; p++);
if((*p&0xC0) == 0x40) p+=2;
if((*p&0xF0) == 0x20){
pes1= p[0]&p[2]&p[4]&1;
}else if((*p&0xF0) == 0x30){
pes1= p[0]&p[2]&p[4]&p[5]&p[7]&p[9]&1;
}else
pes1 = *p == 0x0F;
return pes1||pes2;
}
|
fe21f78d |
static int check_pack_header(const uint8_t *buf) {
return (buf[1] & 0xC0) == 0x40 || (buf[1] & 0xF0) == 0x20;
}
|
db7f1f95 |
static int mpegps_probe(AVProbeData *p)
{ |
9870a7bd |
uint32_t code= -1; |
7e1720de |
int sys=0, pspack=0, priv1=0, vid=0, audio=0, invalid=0; |
95f97de1 |
int i; |
a1c69e0b |
int score=0; |
db7f1f95 |
|
9870a7bd |
for(i=0; i<p->buf_size; i++){
code = (code<<8) + p->buf[i]; |
ec23a472 |
if ((code & 0xffffff00) == 0x100) { |
612dc023 |
int len= p->buf[i+1] << 8 | p->buf[i+2]; |
0c904db1 |
int pes= check_pes(p->buf+i, p->buf+p->buf_size); |
fe21f78d |
int pack = check_pack_header(p->buf+i); |
c6dcd0d7 |
|
25c533a2 |
if(code == SYSTEM_HEADER_START_CODE) sys++; |
fe21f78d |
else if(code == PACK_START_CODE && pack) pspack++; |
274335e7 |
else if((code & 0xf0) == VIDEO_ID && pes) vid++; |
612dc023 |
// skip pes payload to avoid start code emulation for private
// and audio streams
else if((code & 0xe0) == AUDIO_ID && pes) {audio++; i+=len;}
else if(code == PRIVATE_STREAM_1 && pes) {priv1++; i+=len;} |
2f9815dd |
else if(code == 0x1fd && pes) vid++; //VC1 |
7e1720de |
else if((code & 0xf0) == VIDEO_ID && !pes) invalid++;
else if((code & 0xe0) == AUDIO_ID && !pes) invalid++; |
612dc023 |
else if(code == PRIVATE_STREAM_1 && !pes) invalid++; |
ec23a472 |
} |
db7f1f95 |
} |
a1c69e0b |
|
2f9815dd |
if(vid+audio > invalid+1) /* invalid VDR files nd short PES streams */ |
a1c69e0b |
score= AVPROBE_SCORE_MAX/4;
|
7e1720de |
if(sys>invalid && sys*9 <= pspack*10) |
e5cf4d16 |
return (audio > 12 || vid > 3 || pspack > 2) ? AVPROBE_SCORE_MAX/2+2 : AVPROBE_SCORE_MAX/4+1; // +1 for .mpg |
55f65247 |
if(pspack > invalid && (priv1+vid+audio)*10 >= pspack*9) |
c4674a47 |
return pspack > 2 ? AVPROBE_SCORE_MAX/2+2 : AVPROBE_SCORE_MAX/4; // +1 for .mpg
if((!!vid ^ !!audio) && (audio > 4 || vid > 1) && !sys && !pspack && p->buf_size>2048 && vid + audio > invalid) /* PES stream */ |
31d8261c |
return (audio > 12 || vid > 3 + 2*invalid) ? AVPROBE_SCORE_MAX/2+2 : AVPROBE_SCORE_MAX/4; |
a1c69e0b |
//02-Penguin.flac has sys:0 priv1:0 pspack:0 vid:0 audio:1 |
3489e150 |
//mp3_misidentified_2.mp3 has sys:0 priv1:0 pspack:0 vid:0 audio:6 |
31d8261c |
//Have\ Yourself\ a\ Merry\ Little\ Christmas.mp3 0 0 0 5 0 1 len:21618 |
a1c69e0b |
return score; |
db7f1f95 |
}
|
de6d9b64 |
typedef struct MpegDemuxContext { |
191e8ca7 |
int32_t header_state; |
e3d1cd8e |
unsigned char psm_es_type[256]; |
8cd4ac3d |
int sofdec; |
710c4baf |
#if CONFIG_VOBSUB_DEMUXER
AVFormatContext *sub_ctx;
FFDemuxSubtitlesQueue q;
#endif |
de6d9b64 |
} MpegDemuxContext;
|
6e9651d1 |
static int mpegps_read_header(AVFormatContext *s) |
27f388aa |
{
MpegDemuxContext *m = s->priv_data; |
2c187847 |
const char *sofdec = "Sofdec";
int v, i = 0; |
b2f230e2 |
int64_t last_pos = avio_tell(s->pb); |
8cd4ac3d |
|
27f388aa |
m->header_state = 0xff;
s->ctx_flags |= AVFMTCTX_NOHEADER;
|
2c187847 |
m->sofdec = -1;
do { |
e63a3628 |
v = avio_r8(s->pb); |
2c187847 |
m->sofdec++;
} while (v == sofdec[i] && i++ < 6); |
8cd4ac3d |
|
711e69a7 |
m->sofdec = (m->sofdec == 6) ? 1 : 0;
|
b2f230e2 |
if (!m->sofdec)
avio_seek(s->pb, last_pos, SEEK_SET);
|
27f388aa |
/* no need to do more */
return 0;
}
|
471fe57e |
static int64_t get_pts(AVIOContext *pb, int c) |
27f388aa |
{ |
66e9e302 |
uint8_t buf[5];
|
e63a3628 |
buf[0] = c<0 ? avio_r8(pb) : c;
avio_read(pb, buf+1, 4); |
66e9e302 |
return ff_parse_pes_pts(buf); |
27f388aa |
}
|
471fe57e |
static int find_next_start_code(AVIOContext *pb, int *size_ptr, |
191e8ca7 |
int32_t *header_state) |
de6d9b64 |
{
unsigned int state, v;
int val, n;
state = *header_state;
n = *size_ptr;
while (n > 0) {
if (url_feof(pb))
break; |
e63a3628 |
v = avio_r8(pb); |
de6d9b64 |
n--;
if (state == 0x000001) {
state = ((state << 8) | v) & 0xffffff;
val = state;
goto found;
}
state = ((state << 8) | v) & 0xffffff;
}
val = -1;
found:
*header_state = state;
*size_ptr = n;
return val;
}
|
e3d1cd8e |
/** |
49bd8e4b |
* Extract stream types from a program stream map |
e3d1cd8e |
* According to ISO/IEC 13818-1 ('MPEG-2 Systems') table 2-35 |
115329f1 |
* |
e3d1cd8e |
* @return number of bytes occupied by PSM in the bitstream
*/ |
471fe57e |
static long mpegps_psm_parse(MpegDemuxContext *m, AVIOContext *pb) |
e3d1cd8e |
{
int psm_length, ps_info_length, es_map_length;
|
e63a3628 |
psm_length = avio_rb16(pb);
avio_r8(pb);
avio_r8(pb);
ps_info_length = avio_rb16(pb); |
e3d1cd8e |
/* skip program_stream_info */ |
45a8a02a |
avio_skip(pb, ps_info_length); |
e63a3628 |
es_map_length = avio_rb16(pb); |
e3d1cd8e |
/* at least one es available? */
while (es_map_length >= 4){ |
e63a3628 |
unsigned char type = avio_r8(pb);
unsigned char es_id = avio_r8(pb);
uint16_t es_info_length = avio_rb16(pb); |
e3d1cd8e |
/* remember mapping from stream id to stream type */
m->psm_es_type[es_id] = type;
/* skip program_stream_info */ |
45a8a02a |
avio_skip(pb, es_info_length); |
e3d1cd8e |
es_map_length -= 4 + es_info_length;
} |
e63a3628 |
avio_rb32(pb); /* crc32 */ |
e3d1cd8e |
return 2 + psm_length;
}
|
115329f1 |
/* read the next PES header. Return its position in ppos |
27f388aa |
(if not NULL), and its start code, pts and dts.
*/
static int mpegps_read_pes_header(AVFormatContext *s, |
115329f1 |
int64_t *ppos, int *pstart_code, |
8d14a25c |
int64_t *ppts, int64_t *pdts) |
de6d9b64 |
{
MpegDemuxContext *m = s->priv_data; |
27f388aa |
int len, size, startcode, c, flags, header_len; |
aad512b4 |
int pes_ext, ext2_len, id_ext, skip; |
e56cfad0 |
int64_t pts, dts; |
384c9c2f |
int64_t last_sync= avio_tell(s->pb); |
de6d9b64 |
|
e56cfad0 |
error_redo: |
f59d8ff8 |
avio_seek(s->pb, last_sync, SEEK_SET); |
de6d9b64 |
redo: |
27f388aa |
/* next start code (should be immediately after) */
m->header_state = 0xff;
size = MAX_SYNC_SIZE; |
899681cd |
startcode = find_next_start_code(s->pb, &size, &m->header_state); |
384c9c2f |
last_sync = avio_tell(s->pb); |
0332324a |
if (startcode < 0){
if(url_feof(s->pb))
return AVERROR_EOF;
//FIXME we should remember header_state
return AVERROR(EAGAIN);
}
|
de6d9b64 |
if (startcode == PACK_START_CODE)
goto redo;
if (startcode == SYSTEM_HEADER_START_CODE)
goto redo; |
2c187847 |
if (startcode == PADDING_STREAM) { |
45a8a02a |
avio_skip(s->pb, avio_rb16(s->pb)); |
2c187847 |
goto redo;
}
if (startcode == PRIVATE_STREAM_2) { |
e63a3628 |
len = avio_rb16(s->pb); |
2c187847 |
if (!m->sofdec) {
while (len-- >= 6) { |
e63a3628 |
if (avio_r8(s->pb) == 'S') { |
2c187847 |
uint8_t buf[5]; |
e63a3628 |
avio_read(s->pb, buf, sizeof(buf)); |
2c187847 |
m->sofdec = !memcmp(buf, "ofdec", 5);
len -= sizeof(buf);
break;
}
}
m->sofdec -= !m->sofdec;
} |
45a8a02a |
avio_skip(s->pb, len); |
de6d9b64 |
goto redo;
} |
e3d1cd8e |
if (startcode == PROGRAM_STREAM_MAP) { |
899681cd |
mpegps_psm_parse(m, s->pb); |
e3d1cd8e |
goto redo;
} |
115329f1 |
|
de6d9b64 |
/* find matching stream */
if (!((startcode >= 0x1c0 && startcode <= 0x1df) ||
(startcode >= 0x1e0 && startcode <= 0x1ef) || |
aad512b4 |
(startcode == 0x1bd) || (startcode == 0x1fd))) |
de6d9b64 |
goto redo; |
27f388aa |
if (ppos) { |
384c9c2f |
*ppos = avio_tell(s->pb) - 4; |
27f388aa |
} |
e63a3628 |
len = avio_rb16(s->pb); |
75a9fbb9 |
pts = |
b2cac184 |
dts = AV_NOPTS_VALUE; |
de6d9b64 |
/* stuffing */
for(;;) { |
27f388aa |
if (len < 1) |
e56cfad0 |
goto error_redo; |
e63a3628 |
c = avio_r8(s->pb); |
de6d9b64 |
len--;
/* XXX: for mpeg1, should test only bit 7 */ |
115329f1 |
if (c != 0xff) |
de6d9b64 |
break;
}
if ((c & 0xc0) == 0x40) {
/* buffer scale & size */ |
e63a3628 |
avio_r8(s->pb);
c = avio_r8(s->pb); |
de6d9b64 |
len -= 2;
} |
b90ba24b |
if ((c & 0xe0) == 0x20) { |
899681cd |
dts = pts = get_pts(s->pb, c); |
de6d9b64 |
len -= 4; |
b90ba24b |
if (c & 0x10){ |
899681cd |
dts = get_pts(s->pb, -1); |
b90ba24b |
len -= 5;
} |
de6d9b64 |
} else if ((c & 0xc0) == 0x80) {
/* mpeg 2 PES */ |
e63a3628 |
flags = avio_r8(s->pb);
header_len = avio_r8(s->pb); |
de6d9b64 |
len -= 2;
if (header_len > len) |
e56cfad0 |
goto error_redo; |
80036204 |
len -= header_len; |
b90ba24b |
if (flags & 0x80) { |
899681cd |
dts = pts = get_pts(s->pb, -1); |
de6d9b64 |
header_len -= 5; |
b90ba24b |
if (flags & 0x40) { |
899681cd |
dts = get_pts(s->pb, -1); |
b90ba24b |
header_len -= 5;
} |
de6d9b64 |
} |
675b8390 |
if (flags & 0x3f && header_len == 0){
flags &= 0xC0;
av_log(s, AV_LOG_WARNING, "Further flags set but no bytes left\n");
} |
aad512b4 |
if (flags & 0x01) { /* PES extension */ |
e63a3628 |
pes_ext = avio_r8(s->pb); |
aad512b4 |
header_len--;
/* Skip PES private data, program packet sequence counter and P-STD buffer */
skip = (pes_ext >> 4) & 0xb;
skip += skip & 0x9; |
b22d0c04 |
if (pes_ext & 0x40 || skip > header_len){
av_log(s, AV_LOG_WARNING, "pes_ext %X is invalid\n", pes_ext);
pes_ext=skip=0;
} |
45a8a02a |
avio_skip(s->pb, skip); |
aad512b4 |
header_len -= skip;
if (pes_ext & 0x01) { /* PES extension 2 */ |
e63a3628 |
ext2_len = avio_r8(s->pb); |
aad512b4 |
header_len--;
if ((ext2_len & 0x7f) > 0) { |
e63a3628 |
id_ext = avio_r8(s->pb); |
aad512b4 |
if ((id_ext & 0x80) == 0)
startcode = ((startcode & 0xff) << 8) | id_ext;
header_len--;
}
}
} |
80036204 |
if(header_len < 0)
goto error_redo; |
45a8a02a |
avio_skip(s->pb, header_len); |
de6d9b64 |
} |
df70de1f |
else if( c!= 0xf )
goto redo;
|
afa6afcc |
if (startcode == PRIVATE_STREAM_1) { |
e63a3628 |
startcode = avio_r8(s->pb); |
de6d9b64 |
len--;
} |
7e4709b1 |
if(len<0)
goto error_redo; |
b754978a |
if(dts != AV_NOPTS_VALUE && ppos){
int i;
for(i=0; i<s->nb_streams; i++){ |
6ba90c20 |
if(startcode == s->streams[i]->id && |
8978feda |
s->pb->seekable /* index useless on streams anyway */) { |
3dea63bd |
ff_reduce_index(s, i); |
30a43f2d |
av_add_index_entry(s->streams[i], *ppos, dts, 0, 0, AVINDEX_KEYFRAME /* FIXME keyframe? */); |
b754978a |
}
}
} |
115329f1 |
|
27f388aa |
*pstart_code = startcode;
*ppts = pts;
*pdts = dts;
return len;
}
static int mpegps_read_packet(AVFormatContext *s,
AVPacket *pkt)
{ |
e3d1cd8e |
MpegDemuxContext *m = s->priv_data; |
27f388aa |
AVStream *st; |
9fba8ebe |
int len, startcode, i, es_type, ret; |
e9c4f36c |
int lpcm_header_len = -1; //Init to supress warning |
5b56ad03 |
int request_probe= 0; |
36ef5369 |
enum AVCodecID codec_id = AV_CODEC_ID_NONE; |
72415b2a |
enum AVMediaType type; |
b754978a |
int64_t pts, dts, dummy_pos; //dummy_pos is needed for the index building to work |
27f388aa |
redo: |
8d14a25c |
len = mpegps_read_pes_header(s, &dummy_pos, &startcode, &pts, &dts); |
27f388aa |
if (len < 0)
return len; |
115329f1 |
|
ce7cf600 |
if (startcode >= 0x80 && startcode <= 0xcf) {
if(len < 4)
goto skip;
/* audio: skip header */
avio_r8(s->pb); |
759901f8 |
lpcm_header_len = avio_rb16(s->pb); |
ce7cf600 |
len -= 3;
if (startcode >= 0xb0 && startcode <= 0xbf) {
/* MLP/TrueHD audio has a 4-byte header */
avio_r8(s->pb);
len--;
}
}
|
de6d9b64 |
/* now find stream */
for(i=0;i<s->nb_streams;i++) {
st = s->streams[i];
if (st->id == startcode)
goto found;
} |
e3d1cd8e |
es_type = m->psm_es_type[startcode & 0xff];
if(es_type == STREAM_TYPE_VIDEO_MPEG1){ |
36ef5369 |
codec_id = AV_CODEC_ID_MPEG2VIDEO; |
72415b2a |
type = AVMEDIA_TYPE_VIDEO; |
e3d1cd8e |
} else if(es_type == STREAM_TYPE_VIDEO_MPEG2){ |
36ef5369 |
codec_id = AV_CODEC_ID_MPEG2VIDEO; |
72415b2a |
type = AVMEDIA_TYPE_VIDEO; |
e3d1cd8e |
} else if(es_type == STREAM_TYPE_AUDIO_MPEG1 ||
es_type == STREAM_TYPE_AUDIO_MPEG2){ |
36ef5369 |
codec_id = AV_CODEC_ID_MP3; |
72415b2a |
type = AVMEDIA_TYPE_AUDIO; |
e3d1cd8e |
} else if(es_type == STREAM_TYPE_AUDIO_AAC){ |
36ef5369 |
codec_id = AV_CODEC_ID_AAC; |
72415b2a |
type = AVMEDIA_TYPE_AUDIO; |
e3d1cd8e |
} else if(es_type == STREAM_TYPE_VIDEO_MPEG4){ |
36ef5369 |
codec_id = AV_CODEC_ID_MPEG4; |
72415b2a |
type = AVMEDIA_TYPE_VIDEO; |
e3d1cd8e |
} else if(es_type == STREAM_TYPE_VIDEO_H264){ |
36ef5369 |
codec_id = AV_CODEC_ID_H264; |
72415b2a |
type = AVMEDIA_TYPE_VIDEO; |
e3d1cd8e |
} else if(es_type == STREAM_TYPE_AUDIO_AC3){ |
36ef5369 |
codec_id = AV_CODEC_ID_AC3; |
72415b2a |
type = AVMEDIA_TYPE_AUDIO; |
e3d1cd8e |
} else if (startcode >= 0x1e0 && startcode <= 0x1ef) { |
83d07313 |
static const unsigned char avs_seqh[4] = { 0, 0, 1, 0xb0 };
unsigned char buf[8]; |
e63a3628 |
avio_read(s->pb, buf, 8); |
f59d8ff8 |
avio_seek(s->pb, -8, SEEK_CUR); |
83d07313 |
if(!memcmp(buf, avs_seqh, 4) && (buf[6] != 0 || buf[7] != 1)) |
36ef5369 |
codec_id = AV_CODEC_ID_CAVS; |
83d07313 |
else |
5b56ad03 |
request_probe= 1; |
72415b2a |
type = AVMEDIA_TYPE_VIDEO; |
db7f1f95 |
} else if (startcode >= 0x1c0 && startcode <= 0x1df) { |
72415b2a |
type = AVMEDIA_TYPE_AUDIO; |
36ef5369 |
codec_id = m->sofdec > 0 ? AV_CODEC_ID_ADPCM_ADX : AV_CODEC_ID_MP2; |
3f2bf07b |
} else if (startcode >= 0x80 && startcode <= 0x87) { |
72415b2a |
type = AVMEDIA_TYPE_AUDIO; |
36ef5369 |
codec_id = AV_CODEC_ID_AC3; |
274335e7 |
} else if ( ( startcode >= 0x88 && startcode <= 0x8f) |
aad512b4 |
||( startcode >= 0x98 && startcode <= 0x9f)) {
/* 0x90 - 0x97 is reserved for SDDS in DVD specs */ |
72415b2a |
type = AVMEDIA_TYPE_AUDIO; |
36ef5369 |
codec_id = AV_CODEC_ID_DTS; |
aad512b4 |
} else if (startcode >= 0xa0 && startcode <= 0xaf) { |
72415b2a |
type = AVMEDIA_TYPE_AUDIO; |
759901f8 |
if(lpcm_header_len == 6) { |
7a72695c |
codec_id = AV_CODEC_ID_MLP; |
759901f8 |
} else { |
7a72695c |
/* 16 bit form will be handled as AV_CODEC_ID_PCM_S16BE */
codec_id = AV_CODEC_ID_PCM_DVD; |
759901f8 |
} |
aad512b4 |
} else if (startcode >= 0xb0 && startcode <= 0xbf) { |
72415b2a |
type = AVMEDIA_TYPE_AUDIO; |
36ef5369 |
codec_id = AV_CODEC_ID_TRUEHD; |
aad512b4 |
} else if (startcode >= 0xc0 && startcode <= 0xcf) {
/* Used for both AC-3 and E-AC-3 in EVOB files */ |
72415b2a |
type = AVMEDIA_TYPE_AUDIO; |
36ef5369 |
codec_id = AV_CODEC_ID_AC3; |
a9c3213f |
} else if (startcode >= 0x20 && startcode <= 0x3f) { |
72415b2a |
type = AVMEDIA_TYPE_SUBTITLE; |
36ef5369 |
codec_id = AV_CODEC_ID_DVD_SUBTITLE; |
aad512b4 |
} else if (startcode >= 0xfd55 && startcode <= 0xfd5f) { |
72415b2a |
type = AVMEDIA_TYPE_VIDEO; |
36ef5369 |
codec_id = AV_CODEC_ID_VC1; |
db7f1f95 |
} else {
skip:
/* skip packet */ |
45a8a02a |
avio_skip(s->pb, len); |
db7f1f95 |
goto redo;
} |
1e5c667c |
/* no stream found: add a new stream */ |
84ad31ff |
st = avformat_new_stream(s, NULL); |
115329f1 |
if (!st) |
1e5c667c |
goto skip; |
84ad31ff |
st->id = startcode; |
01f4895c |
st->codec->codec_type = type;
st->codec->codec_id = codec_id; |
5b56ad03 |
st->request_probe = request_probe; |
36ef5369 |
if (codec_id != AV_CODEC_ID_PCM_S16BE) |
57004ff1 |
st->need_parsing = AVSTREAM_PARSE_FULL; |
de6d9b64 |
found: |
f3356e9c |
if(st->discard >= AVDISCARD_ALL) |
b9866ebc |
goto skip; |
afa6afcc |
if (startcode >= 0xa0 && startcode <= 0xaf) { |
ad406f7e |
if (lpcm_header_len == 6 && st->codec->codec_id == AV_CODEC_ID_MLP) { |
759901f8 |
if (len < 6)
goto skip;
avio_skip(s->pb, 6);
len -=6;
} else { |
9ec05e36 |
int b1, freq;
/* for LPCM, we just skip the header and consider it is raw
audio data */
if (len <= 3)
goto skip; |
e63a3628 |
avio_r8(s->pb); /* emphasis (1), muse(1), reserved(1), frame number(5) */
b1 = avio_r8(s->pb); /* quant (2), freq(2), reserved(1), channels(3) */
avio_r8(s->pb); /* dynamic range control (0x80 = off) */ |
9ec05e36 |
len -= 3;
freq = (b1 >> 4) & 3; |
01f4895c |
st->codec->sample_rate = lpcm_freq_tab[freq];
st->codec->channels = 1 + (b1 & 7); |
dd1c8f3e |
st->codec->bits_per_coded_sample = 16 + ((b1 >> 6) & 3) * 4; |
4860abb1 |
st->codec->bit_rate = st->codec->channels *
st->codec->sample_rate * |
dd1c8f3e |
st->codec->bits_per_coded_sample;
if (st->codec->bits_per_coded_sample == 16) |
36ef5369 |
st->codec->codec_id = AV_CODEC_ID_PCM_S16BE; |
dd1c8f3e |
else if (st->codec->bits_per_coded_sample == 28) |
4860abb1 |
return AVERROR(EINVAL); |
759901f8 |
} |
9ec05e36 |
} |
98ef887a |
ret = av_get_packet(s->pb, pkt, len); |
de6d9b64 |
pkt->pts = pts; |
27f388aa |
pkt->dts = dts; |
c45ebd54 |
pkt->pos = dummy_pos; |
db7f1f95 |
pkt->stream_index = st->index; |
b751f611 |
av_dlog(s, "%d: pts=%0.3f dts=%0.3f size=%d\n", |
045dd4b9 |
pkt->stream_index, pkt->pts / 90000.0, pkt->dts / 90000.0,
pkt->size); |
0bd586c5 |
|
9fba8ebe |
return (ret < 0) ? ret : 0; |
de6d9b64 |
}
|
115329f1 |
static int64_t mpegps_read_dts(AVFormatContext *s, int stream_index, |
8d14a25c |
int64_t *ppos, int64_t pos_limit) |
27f388aa |
{
int len, startcode;
int64_t pos, pts, dts;
pos = *ppos; |
f59d8ff8 |
if (avio_seek(s->pb, pos, SEEK_SET) < 0) |
5faf1689 |
return AV_NOPTS_VALUE;
|
27f388aa |
for(;;) { |
8d14a25c |
len = mpegps_read_pes_header(s, &pos, &startcode, &pts, &dts); |
27f388aa |
if (len < 0) { |
919d7a34 |
av_dlog(s, "none (ret=%d)\n", len); |
27f388aa |
return AV_NOPTS_VALUE;
} |
115329f1 |
if (startcode == s->streams[stream_index]->id && |
27f388aa |
dts != AV_NOPTS_VALUE) {
break;
} |
45a8a02a |
avio_skip(s->pb, len); |
27f388aa |
} |
919d7a34 |
av_dlog(s, "pos=0x%"PRIx64" dts=0x%"PRIx64" %0.3f\n",
pos, dts, dts / 90000.0); |
27f388aa |
*ppos = pos; |
cdd5034f |
return dts; |
27f388aa |
}
|
66355be3 |
AVInputFormat ff_mpegps_demuxer = { |
dfc2c4d9 |
.name = "mpeg", |
0177b7d2 |
.long_name = NULL_IF_CONFIG_SMALL("MPEG-PS (MPEG-2 Program Stream)"), |
dfc2c4d9 |
.priv_data_size = sizeof(MpegDemuxContext),
.read_probe = mpegps_probe,
.read_header = mpegps_read_header,
.read_packet = mpegps_read_packet,
.read_timestamp = mpegps_read_dts, |
20234a4b |
.flags = AVFMT_SHOW_IDS | AVFMT_TS_DISCONT, |
de6d9b64 |
}; |
710c4baf |
#if CONFIG_VOBSUB_DEMUXER
#define REF_STRING "# VobSub index file,"
static int vobsub_probe(AVProbeData *p)
{
if (!strncmp(p->buf, REF_STRING, sizeof(REF_STRING) - 1))
return AVPROBE_SCORE_MAX;
return 0;
}
static int vobsub_read_header(AVFormatContext *s)
{ |
5a2f3f0b |
int i, ret = 0, header_parsed = 0, langidx = 0; |
710c4baf |
MpegDemuxContext *vobsub = s->priv_data;
char *sub_name = NULL;
size_t fname_len;
char *ext, *header_str;
AVBPrint header;
int64_t delay = 0;
AVStream *st = NULL;
sub_name = av_strdup(s->filename);
fname_len = strlen(sub_name);
ext = sub_name - 3 + fname_len;
if (fname_len < 4 || *(ext - 1) != '.') {
av_log(s, AV_LOG_ERROR, "The input index filename is too short "
"to guess the associated .SUB file\n");
ret = AVERROR_INVALIDDATA;
goto end;
}
memcpy(ext, !strncmp(ext, "IDX", 3) ? "SUB" : "sub", 3);
av_log(s, AV_LOG_VERBOSE, "IDX/SUB: %s -> %s\n", s->filename, sub_name);
ret = avformat_open_input(&vobsub->sub_ctx, sub_name, &ff_mpegps_demuxer, NULL);
if (ret < 0) {
av_log(s, AV_LOG_ERROR, "Unable to open %s as MPEG subtitles\n", sub_name);
goto end;
}
av_bprint_init(&header, 0, AV_BPRINT_SIZE_UNLIMITED);
while (!url_feof(s->pb)) {
char line[2048];
int len = ff_get_line(s->pb, line, sizeof(line));
if (!len)
break;
line[strcspn(line, "\r\n")] = 0;
if (!strncmp(line, "id:", 3)) {
int n, stream_id = 0;
char id[64] = {0};
n = sscanf(line, "id: %63[^,], index: %u", id, &stream_id);
if (n != 2) {
av_log(s, AV_LOG_WARNING, "Unable to parse index line '%s', "
"assuming 'id: und, index: 0'\n", line);
strcpy(id, "und");
stream_id = 0;
}
st = avformat_new_stream(s, NULL);
if (!st) {
ret = AVERROR(ENOMEM);
goto end;
}
st->id = stream_id;
st->codec->codec_type = AVMEDIA_TYPE_SUBTITLE;
st->codec->codec_id = AV_CODEC_ID_DVD_SUBTITLE; |
8cea63c4 |
avpriv_set_pts_info(st, 64, 1, 1000); |
710c4baf |
av_dict_set(&st->metadata, "language", id, 0);
av_log(s, AV_LOG_DEBUG, "IDX stream[%d] id=%s\n", stream_id, id);
header_parsed = 1;
} else if (st && !strncmp(line, "timestamp:", 10)) {
AVPacket *sub;
int hh, mm, ss, ms;
int64_t pos, timestamp;
const char *p = line + 10;
if (sscanf(p, "%02d:%02d:%02d:%03d, filepos: %"PRIx64,
&hh, &mm, &ss, &ms, &pos) != 5) {
av_log(s, AV_LOG_ERROR, "Unable to parse timestamp line '%s', "
"abort parsing\n", line);
break;
}
timestamp = (hh*3600LL + mm*60LL + ss) * 1000LL + ms + delay;
timestamp = av_rescale_q(timestamp, (AVRational){1,1000}, st->time_base);
sub = ff_subtitles_queue_insert(&vobsub->q, "", 0, 0);
if (!sub) {
ret = AVERROR(ENOMEM);
goto end;
}
sub->pos = pos;
sub->pts = timestamp;
sub->stream_index = s->nb_streams - 1;
} else if (st && !strncmp(line, "alt:", 4)) {
const char *p = line + 4;
while (*p == ' ')
p++;
av_dict_set(&st->metadata, "title", p, 0);
av_log(s, AV_LOG_DEBUG, "IDX stream[%d] name=%s\n", st->id, p);
header_parsed = 1;
} else if (!strncmp(line, "delay:", 6)) {
int sign = 1, hh = 0, mm = 0, ss = 0, ms = 0;
const char *p = line + 6;
while (*p == ' ')
p++;
if (*p == '-' || *p == '+') {
sign = *p == '-' ? -1 : 1;
p++;
}
sscanf(p, "%d:%d:%d:%d", &hh, &mm, &ss, &ms);
delay = ((hh*3600LL + mm*60LL + ss) * 1000LL + ms) * sign;
} else if (!strncmp(line, "langidx:", 8)) {
const char *p = line + 8;
if (sscanf(p, "%d", &langidx) != 1)
av_log(s, AV_LOG_ERROR, "Invalid langidx specified\n");
} else if (!header_parsed) {
if (line[0] && line[0] != '#')
av_bprintf(&header, "%s\n", line);
}
}
if (langidx < s->nb_streams)
s->streams[langidx]->disposition |= AV_DISPOSITION_DEFAULT;
ff_subtitles_queue_finalize(&vobsub->q);
if (!av_bprint_is_complete(&header)) {
av_bprint_finalize(&header, NULL);
ret = AVERROR(ENOMEM);
goto end;
}
av_bprint_finalize(&header, &header_str);
for (i = 0; i < s->nb_streams; i++) {
AVStream *sub_st = s->streams[i];
sub_st->codec->extradata = av_strdup(header_str); |
5a2f3f0b |
sub_st->codec->extradata_size = header.len; |
710c4baf |
}
av_free(header_str);
end:
av_free(sub_name);
return ret;
}
static int vobsub_read_packet(AVFormatContext *s, AVPacket *pkt)
{
MpegDemuxContext *vobsub = s->priv_data;
FFDemuxSubtitlesQueue *q = &vobsub->q;
AVIOContext *pb = vobsub->sub_ctx->pb;
int ret, psize, len16 = -1;
AVPacket idx_pkt;
ret = ff_subtitles_queue_read_packet(q, &idx_pkt);
if (ret < 0)
return ret;
/* compute maximum packet size using the next packet position. This is
* useful when the len in the header is non-sense */
if (q->current_sub_idx < q->nb_subs) {
psize = q->subs[q->current_sub_idx].pos - idx_pkt.pos;
} else {
int64_t fsize = avio_size(pb);
psize = fsize < 0 ? 0xffff : fsize - idx_pkt.pos;
}
avio_seek(pb, idx_pkt.pos, SEEK_SET);
av_init_packet(pkt);
pkt->size = 0;
pkt->data = NULL;
do {
int n, to_read, startcode;
int64_t pts, dts;
ret = mpegps_read_pes_header(vobsub->sub_ctx, NULL, &startcode, &pts, &dts);
if (ret < 0)
return ret;
to_read = ret & 0xffff;
/* this prevents reads above the current packet */
if (pkt->size + to_read > psize)
break;
/* if the len is computed, we check for overread */
if (len16 != -1 && pkt->size + to_read > len16)
break;
/* the current chunk doesn't match the stream index (unlikely) */
if ((startcode & 0x1f) != idx_pkt.stream_index)
break;
ret = av_grow_packet(pkt, to_read);
if (ret < 0)
return ret;
n = avio_read(pb, pkt->data + (pkt->size - to_read), to_read);
if (n < to_read)
pkt->size -= to_read - n;
/* first chunk contains the total len of the packet to raise */
if (len16 == -1 && n > 2)
len16 = AV_RB16(pkt->data);
} while (len16 != -1 && pkt->size != len16);
pkt->pts = pkt->dts = idx_pkt.pts;
pkt->pos = idx_pkt.pos;
pkt->stream_index = idx_pkt.stream_index;
return 0;
}
static int vobsub_read_seek(AVFormatContext *s, int stream_index,
int64_t min_ts, int64_t ts, int64_t max_ts, int flags)
{
MpegDemuxContext *vobsub = s->priv_data; |
8cea63c4 |
/* Rescale requested timestamps based on the first stream (timebase is the
* same for all subtitles stream within a .idx/.sub). Rescaling is done just
* like in avformat_seek_file(). */
if (stream_index == -1 && s->nb_streams != 1) {
AVRational time_base = s->streams[0]->time_base;
ts = av_rescale_q(ts, AV_TIME_BASE_Q, time_base);
min_ts = av_rescale_rnd(min_ts, time_base.den,
time_base.num * (int64_t)AV_TIME_BASE,
AV_ROUND_UP | AV_ROUND_PASS_MINMAX);
max_ts = av_rescale_rnd(max_ts, time_base.den,
time_base.num * (int64_t)AV_TIME_BASE,
AV_ROUND_DOWN | AV_ROUND_PASS_MINMAX);
}
|
710c4baf |
return ff_subtitles_queue_seek(&vobsub->q, s, stream_index,
min_ts, ts, max_ts, flags);
}
static int vobsub_read_close(AVFormatContext *s)
{
MpegDemuxContext *vobsub = s->priv_data;
ff_subtitles_queue_clean(&vobsub->q);
if (vobsub->sub_ctx)
avformat_close_input(&vobsub->sub_ctx);
return 0;
}
AVInputFormat ff_vobsub_demuxer = {
.name = "vobsub",
.long_name = NULL_IF_CONFIG_SMALL("VobSub subtitle format"),
.priv_data_size = sizeof(MpegDemuxContext),
.read_probe = vobsub_probe,
.read_header = vobsub_read_header,
.read_packet = vobsub_read_packet,
.read_seek2 = vobsub_read_seek,
.read_close = vobsub_read_close,
.flags = AVFMT_SHOW_IDS,
.extensions = "idx",
};
#endif |