2001-07-22 14:18:56 +00:00
|
|
|
/*
|
2007-06-21 09:39:29 +00:00
|
|
|
* MPEG1/2 demuxer
|
2009-01-19 15:46:40 +00:00
|
|
|
* Copyright (c) 2000, 2001, 2002 Fabrice Bellard
|
2001-07-22 14:18:56 +00:00
|
|
|
*
|
2006-10-07 15:30:46 +00:00
|
|
|
* This file is part of FFmpeg.
|
|
|
|
*
|
|
|
|
* FFmpeg is free software; you can redistribute it and/or
|
2002-05-25 22:34:32 +00:00
|
|
|
* modify it under the terms of the GNU Lesser General Public
|
|
|
|
* License as published by the Free Software Foundation; either
|
2006-10-07 15:30:46 +00:00
|
|
|
* version 2.1 of the License, or (at your option) any later version.
|
2001-07-22 14:18:56 +00:00
|
|
|
*
|
2006-10-07 15:30:46 +00:00
|
|
|
* FFmpeg is distributed in the hope that it will be useful,
|
2001-07-22 14:18:56 +00:00
|
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
2002-05-25 22:34:32 +00:00
|
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
|
|
|
* Lesser General Public License for more details.
|
2001-07-22 14:18:56 +00:00
|
|
|
*
|
2002-05-25 22:34:32 +00:00
|
|
|
* You should have received a copy of the GNU Lesser General Public
|
2006-10-07 15:30:46 +00:00
|
|
|
* License along with FFmpeg; if not, write to the Free Software
|
2006-01-12 22:43:26 +00:00
|
|
|
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
|
2001-07-22 14:18:56 +00:00
|
|
|
*/
|
2007-06-21 09:39:29 +00:00
|
|
|
|
2001-07-22 14:18:56 +00:00
|
|
|
#include "avformat.h"
|
2011-02-06 14:38:55 +00:00
|
|
|
#include "internal.h"
|
2007-06-21 09:39:29 +00:00
|
|
|
#include "mpeg.h"
|
2001-07-22 14:18:56 +00:00
|
|
|
|
2012-09-03 00:51:00 +00:00
|
|
|
#if CONFIG_VOBSUB_DEMUXER
|
|
|
|
# include "subtitles.h"
|
|
|
|
# include "libavutil/bprint.h"
|
|
|
|
#endif
|
|
|
|
|
2004-01-13 22:02:49 +00:00
|
|
|
#undef NDEBUG
|
|
|
|
#include <assert.h>
|
2013-03-17 09:21:12 +00:00
|
|
|
#include "libavutil/avassert.h"
|
2004-01-13 22:02:49 +00:00
|
|
|
|
2001-07-22 14:18:56 +00:00
|
|
|
/*********************************************/
|
|
|
|
/* demux code */
|
|
|
|
|
|
|
|
#define MAX_SYNC_SIZE 100000
|
|
|
|
|
2014-03-24 04:28:07 +00:00
|
|
|
static int check_pes(const uint8_t *p, const uint8_t *end)
|
2014-03-20 01:02:42 +00:00
|
|
|
{
|
2007-11-03 13:48:30 +00:00
|
|
|
int pes1;
|
2014-03-20 01:02:42 +00:00
|
|
|
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
|
2007-11-03 13:48:30 +00:00
|
|
|
pes1 = *p == 0x0F;
|
|
|
|
|
2014-03-20 01:02:42 +00:00
|
|
|
return pes1 || pes2;
|
2007-11-03 13:48:30 +00:00
|
|
|
}
|
|
|
|
|
2014-03-20 01:02:42 +00:00
|
|
|
static int check_pack_header(const uint8_t *buf)
|
|
|
|
{
|
2011-09-28 22:43:24 +00:00
|
|
|
return (buf[1] & 0xC0) == 0x40 || (buf[1] & 0xF0) == 0x20;
|
|
|
|
}
|
|
|
|
|
2002-05-20 16:29:40 +00:00
|
|
|
static int mpegps_probe(AVProbeData *p)
|
|
|
|
{
|
2014-03-20 01:02:42 +00:00
|
|
|
uint32_t code = -1;
|
2004-10-01 16:00:00 +00:00
|
|
|
int i;
|
2014-03-20 01:02:42 +00:00
|
|
|
int sys = 0, pspack = 0, priv1 = 0, vid = 0;
|
|
|
|
int audio = 0, invalid = 0, score = 0;
|
2014-12-06 21:33:09 +00:00
|
|
|
int endpes = 0;
|
2002-05-20 16:29:40 +00:00
|
|
|
|
2014-03-20 01:02:42 +00:00
|
|
|
for (i = 0; i < p->buf_size; i++) {
|
|
|
|
code = (code << 8) + p->buf[i];
|
2003-07-10 09:04:04 +00:00
|
|
|
if ((code & 0xffffff00) == 0x100) {
|
2014-03-20 01:02:42 +00:00
|
|
|
int len = p->buf[i + 1] << 8 | p->buf[i + 2];
|
2014-12-06 21:33:09 +00:00
|
|
|
int pes = endpes <= i && check_pes(p->buf + i, p->buf + p->buf_size);
|
2014-03-20 01:02:42 +00:00
|
|
|
int pack = check_pack_header(p->buf + i);
|
|
|
|
|
|
|
|
if (code == SYSTEM_HEADER_START_CODE)
|
|
|
|
sys++;
|
|
|
|
else if (code == PACK_START_CODE && pack)
|
|
|
|
pspack++;
|
2014-12-06 21:33:09 +00:00
|
|
|
else if ((code & 0xf0) == VIDEO_ID && pes) {
|
|
|
|
endpes = i + len;
|
2014-03-20 01:02:42 +00:00
|
|
|
vid++;
|
2014-12-06 21:33:09 +00:00
|
|
|
}
|
2010-05-24 12:32:13 +00:00
|
|
|
// skip pes payload to avoid start code emulation for private
|
|
|
|
// and audio streams
|
2014-03-24 04:28:07 +00:00
|
|
|
else if ((code & 0xe0) == AUDIO_ID && pes) {audio++; i+=len;}
|
|
|
|
else if (code == PRIVATE_STREAM_1 && pes) {priv1++; i+=len;}
|
|
|
|
else if (code == 0x1fd && pes) vid++; //VC1
|
2007-12-03 09:37:06 +00:00
|
|
|
|
2014-03-24 04:28:07 +00:00
|
|
|
else if ((code & 0xf0) == VIDEO_ID && !pes) invalid++;
|
|
|
|
else if ((code & 0xe0) == AUDIO_ID && !pes) invalid++;
|
|
|
|
else if (code == PRIVATE_STREAM_1 && !pes) invalid++;
|
2003-07-10 09:04:04 +00:00
|
|
|
}
|
2002-05-20 16:29:40 +00:00
|
|
|
}
|
2006-08-19 08:39:00 +00:00
|
|
|
|
2014-03-24 04:28:07 +00:00
|
|
|
if (vid + audio > invalid + 1) /* invalid VDR files nd short PES streams */
|
2013-03-25 15:12:51 +00:00
|
|
|
score = AVPROBE_SCORE_EXTENSION / 2;
|
2006-08-19 08:39:00 +00:00
|
|
|
|
2014-12-06 21:38:38 +00:00
|
|
|
// av_log(NULL, AV_LOG_ERROR, "vid:%d aud:%d sys:%d pspack:%d invalid:%d size:%d \n",
|
|
|
|
// vid, audio, sys, pspack, invalid, p->buf_size);
|
|
|
|
|
2014-03-20 01:02:42 +00:00
|
|
|
if (sys > invalid && sys * 9 <= pspack * 10)
|
2014-03-24 04:28:07 +00:00
|
|
|
return (audio > 12 || vid > 3 || pspack > 2) ? AVPROBE_SCORE_EXTENSION + 2
|
2014-09-09 00:51:59 +00:00
|
|
|
: AVPROBE_SCORE_EXTENSION / 2 + 1; // 1 more than mp3
|
2014-03-20 01:02:42 +00:00
|
|
|
if (pspack > invalid && (priv1 + vid + audio) * 10 >= pspack * 9)
|
|
|
|
return pspack > 2 ? AVPROBE_SCORE_EXTENSION + 2
|
|
|
|
: AVPROBE_SCORE_EXTENSION / 2; // 1 more than .mpg
|
|
|
|
if ((!!vid ^ !!audio) && (audio > 4 || vid > 1) && !sys &&
|
|
|
|
!pspack && p->buf_size > 2048 && vid + audio > invalid) /* PES stream */
|
2014-03-24 04:28:07 +00:00
|
|
|
return (audio > 12 || vid > 3 + 2 * invalid) ? AVPROBE_SCORE_EXTENSION + 2
|
|
|
|
: AVPROBE_SCORE_EXTENSION / 2;
|
2014-03-20 01:02:42 +00:00
|
|
|
|
|
|
|
// 02-Penguin.flac has sys:0 priv1:0 pspack:0 vid:0 audio:1
|
|
|
|
// mp3_misidentified_2.mp3 has sys:0 priv1:0 pspack:0 vid:0 audio:6
|
2014-03-24 04:28:07 +00:00
|
|
|
// Have\ Yourself\ a\ Merry\ Little\ Christmas.mp3 0 0 0 5 0 1 len:21618
|
2006-08-19 08:39:00 +00:00
|
|
|
return score;
|
2002-05-20 16:29:40 +00:00
|
|
|
}
|
|
|
|
|
2001-07-22 14:18:56 +00:00
|
|
|
typedef struct MpegDemuxContext {
|
2006-09-27 19:47:39 +00:00
|
|
|
int32_t header_state;
|
2005-03-28 17:33:21 +00:00
|
|
|
unsigned char psm_es_type[256];
|
2007-11-07 23:56:00 +00:00
|
|
|
int sofdec;
|
2013-03-17 09:21:12 +00:00
|
|
|
int dvd;
|
2013-03-27 00:48:07 +00:00
|
|
|
int imkh_cctv;
|
2012-09-03 00:51:00 +00:00
|
|
|
#if CONFIG_VOBSUB_DEMUXER
|
|
|
|
AVFormatContext *sub_ctx;
|
avformat/vobsub: fix several issues.
Here is an extract of fate-samples/sub/vobsub.idx, with an additional
text at the end of each line to better identify each bitmap:
timestamp: 00:04:55:445, filepos: 00001b000 Ace!
timestamp: 00:05:00:049, filepos: 00001b800 Wake up, honey!
timestamp: 00:05:02:018, filepos: 00001c800 I gotta go to work.
timestamp: 00:05:02:035, filepos: 00001d000 <???>
timestamp: 00:05:04:203, filepos: 00001d800 Look after Clayton, okay?
timestamp: 00:05:05:947, filepos: 00001e800 I'll be back tonight.
timestamp: 00:05:07:957, filepos: 00001f800 Bye! Love you.
timestamp: 00:05:21:295, filepos: 000020800 Hey, Ace! What's up?
timestamp: 00:05:23:356, filepos: 000021800 Hey, how's it going?
timestamp: 00:05:24:640, filepos: 000022800 Remember what today is? The 3rd!
timestamp: 00:05:27:193, filepos: 000023800 Look over there!
timestamp: 00:05:28:369, filepos: 000024800 Where are they going?
timestamp: 00:05:28:361, filepos: 000025000 <???>
timestamp: 00:05:29:946, filepos: 000025800 Let's go see.
timestamp: 00:05:31:230, filepos: 000026000 I can't, man. I got Clayton.
Note the two "<???>": they are basically split subtitles (with the
previous one), which the dvdsub decoder is now supposed to reconstruct
with a previous commit. But also note that while the first chunk has
increasing timestamps,
timestamp: 00:05:02:018, filepos: 00001c800
timestamp: 00:05:02:035, filepos: 00001d000
...it's not the case of the second one (and this is not an exception in the
original file):
timestamp: 00:05:28:369, filepos: 000024800
timestamp: 00:05:28:361, filepos: 000025000
For the dvdsub decoder, they need to be "filepos'ed" ordered, but the
FFDemuxSubtitlesQueue is timestamps ordered, which is the reason of the
introduction of a sub sort method in the context, to allow giving
priority to the position, and then the timestamps. With that change, the
dvdsub decoder get fed with ordered packets.
Now the packet size estimation was also broken: the filepos differences
in the vobsub index defines the full data read between two subtitles
chunks, and it is necessary to take into account what is read by the
mpegps_read_pes_header() function since the length returned by that
function doesn't count the size of the data it reads. This is fixed with
the introduction of total_read, and {old,new}_pos. By doing this change,
we can drop the unreliable len16 heuristic and simplify the whole loop.
Note that mpegps_read_pes_header() often read more than one PES packet
(typically in one call it can read 0x1ba and 0x1be chunk along with the
relevant 0x1bd packet), which triggers the "total_read + pkt_size >
psize" check. This is an expected behaviour, which could be avoided by
having a more chunked version of mpegps_read_pes_header().
The latest change is the extraction of each stream into its own
subtitles queue. If we don't do this, the maximum size for a subtitle
chunk is broken, and the previous changes can not work. Having each
stream in a different queue requires some little adjustments in the
seek code of the demuxer.
This commit is only meaningful as a whole change and can not be easily
split. The FATE test changes because it uses the vobsub demuxer.
2013-09-29 20:05:14 +00:00
|
|
|
FFDemuxSubtitlesQueue q[32];
|
2012-09-03 00:51:00 +00:00
|
|
|
#endif
|
2001-07-22 14:18:56 +00:00
|
|
|
} MpegDemuxContext;
|
|
|
|
|
2012-01-12 12:20:36 +00:00
|
|
|
static int mpegps_read_header(AVFormatContext *s)
|
2003-11-10 18:47:52 +00:00
|
|
|
{
|
|
|
|
MpegDemuxContext *m = s->priv_data;
|
2013-03-27 00:48:07 +00:00
|
|
|
char buffer[7];
|
2011-09-17 12:59:00 +00:00
|
|
|
int64_t last_pos = avio_tell(s->pb);
|
2007-11-07 23:56:00 +00:00
|
|
|
|
2003-11-10 18:47:52 +00:00
|
|
|
m->header_state = 0xff;
|
2014-03-20 01:02:42 +00:00
|
|
|
s->ctx_flags |= AVFMTCTX_NOHEADER;
|
2003-11-10 18:47:52 +00:00
|
|
|
|
2013-03-27 00:48:07 +00:00
|
|
|
avio_get_str(s->pb, 6, buffer, sizeof(buffer));
|
|
|
|
if (!memcmp("IMKH", buffer, 4)) {
|
|
|
|
m->imkh_cctv = 1;
|
|
|
|
} else if (!memcmp("Sofdec", buffer, 6)) {
|
|
|
|
m->sofdec = 1;
|
|
|
|
} else
|
2011-09-17 12:59:00 +00:00
|
|
|
avio_seek(s->pb, last_pos, SEEK_SET);
|
|
|
|
|
2003-11-10 18:47:52 +00:00
|
|
|
/* no need to do more */
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2011-02-20 10:04:12 +00:00
|
|
|
static int64_t get_pts(AVIOContext *pb, int c)
|
2003-11-10 18:47:52 +00:00
|
|
|
{
|
2008-01-07 23:32:57 +00:00
|
|
|
uint8_t buf[5];
|
|
|
|
|
2014-03-20 01:02:42 +00:00
|
|
|
buf[0] = c < 0 ? avio_r8(pb) : c;
|
|
|
|
avio_read(pb, buf + 1, 4);
|
2008-01-07 23:32:57 +00:00
|
|
|
|
|
|
|
return ff_parse_pes_pts(buf);
|
2003-11-10 18:47:52 +00:00
|
|
|
}
|
|
|
|
|
2011-02-20 10:04:12 +00:00
|
|
|
static int find_next_start_code(AVIOContext *pb, int *size_ptr,
|
2006-09-27 19:47:39 +00:00
|
|
|
int32_t *header_state)
|
2001-07-22 14:18:56 +00:00
|
|
|
{
|
|
|
|
unsigned int state, v;
|
|
|
|
int val, n;
|
|
|
|
|
|
|
|
state = *header_state;
|
2014-03-20 01:02:42 +00:00
|
|
|
n = *size_ptr;
|
2001-07-22 14:18:56 +00:00
|
|
|
while (n > 0) {
|
2014-08-07 20:12:41 +00:00
|
|
|
if (avio_feof(pb))
|
2001-07-22 14:18:56 +00:00
|
|
|
break;
|
2011-02-21 15:43:01 +00:00
|
|
|
v = avio_r8(pb);
|
2001-07-22 14:18:56 +00:00
|
|
|
n--;
|
|
|
|
if (state == 0x000001) {
|
|
|
|
state = ((state << 8) | v) & 0xffffff;
|
2014-03-20 01:02:42 +00:00
|
|
|
val = state;
|
2001-07-22 14:18:56 +00:00
|
|
|
goto found;
|
|
|
|
}
|
|
|
|
state = ((state << 8) | v) & 0xffffff;
|
|
|
|
}
|
|
|
|
val = -1;
|
2014-03-20 01:02:42 +00:00
|
|
|
|
|
|
|
found:
|
2001-07-22 14:18:56 +00:00
|
|
|
*header_state = state;
|
2014-03-20 01:02:42 +00:00
|
|
|
*size_ptr = n;
|
2001-07-22 14:18:56 +00:00
|
|
|
return val;
|
|
|
|
}
|
|
|
|
|
2005-03-28 17:33:21 +00:00
|
|
|
/**
|
2010-06-30 15:38:06 +00:00
|
|
|
* Extract stream types from a program stream map
|
2005-03-28 17:33:21 +00:00
|
|
|
* According to ISO/IEC 13818-1 ('MPEG-2 Systems') table 2-35
|
2005-12-17 18:14:38 +00:00
|
|
|
*
|
2005-03-28 17:33:21 +00:00
|
|
|
* @return number of bytes occupied by PSM in the bitstream
|
|
|
|
*/
|
2011-02-20 10:04:12 +00:00
|
|
|
static long mpegps_psm_parse(MpegDemuxContext *m, AVIOContext *pb)
|
2005-03-28 17:33:21 +00:00
|
|
|
{
|
|
|
|
int psm_length, ps_info_length, es_map_length;
|
|
|
|
|
2011-02-21 15:43:01 +00:00
|
|
|
psm_length = avio_rb16(pb);
|
|
|
|
avio_r8(pb);
|
|
|
|
avio_r8(pb);
|
|
|
|
ps_info_length = avio_rb16(pb);
|
2005-03-28 17:33:21 +00:00
|
|
|
|
|
|
|
/* skip program_stream_info */
|
2011-03-15 08:14:38 +00:00
|
|
|
avio_skip(pb, ps_info_length);
|
2015-01-13 23:06:43 +00:00
|
|
|
/*es_map_length = */avio_rb16(pb);
|
2013-12-05 20:17:21 +00:00
|
|
|
/* Ignore es_map_length, trust psm_length */
|
|
|
|
es_map_length = psm_length - ps_info_length - 10;
|
2005-03-28 17:33:21 +00:00
|
|
|
|
|
|
|
/* at least one es available? */
|
2014-03-20 01:02:42 +00:00
|
|
|
while (es_map_length >= 4) {
|
2011-02-21 15:43:01 +00:00
|
|
|
unsigned char type = avio_r8(pb);
|
|
|
|
unsigned char es_id = avio_r8(pb);
|
|
|
|
uint16_t es_info_length = avio_rb16(pb);
|
2014-03-20 01:02:42 +00:00
|
|
|
|
2005-03-28 17:33:21 +00:00
|
|
|
/* remember mapping from stream id to stream type */
|
|
|
|
m->psm_es_type[es_id] = type;
|
|
|
|
/* skip program_stream_info */
|
2011-03-15 08:14:38 +00:00
|
|
|
avio_skip(pb, es_info_length);
|
2005-03-28 17:33:21 +00:00
|
|
|
es_map_length -= 4 + es_info_length;
|
|
|
|
}
|
2011-02-21 15:43:01 +00:00
|
|
|
avio_rb32(pb); /* crc32 */
|
2005-03-28 17:33:21 +00:00
|
|
|
return 2 + psm_length;
|
|
|
|
}
|
|
|
|
|
2005-12-17 18:14:38 +00:00
|
|
|
/* read the next PES header. Return its position in ppos
|
2014-03-20 01:02:42 +00:00
|
|
|
* (if not NULL), and its start code, pts and dts.
|
2003-11-10 18:47:52 +00:00
|
|
|
*/
|
|
|
|
static int mpegps_read_pes_header(AVFormatContext *s,
|
2005-12-17 18:14:38 +00:00
|
|
|
int64_t *ppos, int *pstart_code,
|
2004-04-12 16:50:03 +00:00
|
|
|
int64_t *ppts, int64_t *pdts)
|
2001-07-22 14:18:56 +00:00
|
|
|
{
|
|
|
|
MpegDemuxContext *m = s->priv_data;
|
2003-11-10 18:47:52 +00:00
|
|
|
int len, size, startcode, c, flags, header_len;
|
2007-02-06 19:14:16 +00:00
|
|
|
int pes_ext, ext2_len, id_ext, skip;
|
2007-01-17 10:19:10 +00:00
|
|
|
int64_t pts, dts;
|
2014-03-20 01:02:42 +00:00
|
|
|
int64_t last_sync = avio_tell(s->pb);
|
|
|
|
|
|
|
|
error_redo:
|
|
|
|
avio_seek(s->pb, last_sync, SEEK_SET);
|
|
|
|
redo:
|
|
|
|
/* next start code (should be immediately after) */
|
|
|
|
m->header_state = 0xff;
|
|
|
|
size = MAX_SYNC_SIZE;
|
|
|
|
startcode = find_next_start_code(s->pb, &size, &m->header_state);
|
|
|
|
last_sync = avio_tell(s->pb);
|
|
|
|
if (startcode < 0) {
|
2014-08-07 20:12:41 +00:00
|
|
|
if (avio_feof(s->pb))
|
2010-02-10 14:25:57 +00:00
|
|
|
return AVERROR_EOF;
|
2014-03-20 01:02:42 +00:00
|
|
|
// FIXME we should remember header_state
|
2010-02-10 14:25:57 +00:00
|
|
|
return AVERROR(EAGAIN);
|
|
|
|
}
|
|
|
|
|
2001-07-22 14:18:56 +00:00
|
|
|
if (startcode == PACK_START_CODE)
|
|
|
|
goto redo;
|
|
|
|
if (startcode == SYSTEM_HEADER_START_CODE)
|
|
|
|
goto redo;
|
2007-11-08 21:27:37 +00:00
|
|
|
if (startcode == PADDING_STREAM) {
|
2011-03-15 08:14:38 +00:00
|
|
|
avio_skip(s->pb, avio_rb16(s->pb));
|
2007-11-08 21:27:37 +00:00
|
|
|
goto redo;
|
|
|
|
}
|
|
|
|
if (startcode == PRIVATE_STREAM_2) {
|
|
|
|
if (!m->sofdec) {
|
2013-03-17 09:21:12 +00:00
|
|
|
/* Need to detect whether this from a DVD or a 'Sofdec' stream */
|
|
|
|
int len = avio_rb16(s->pb);
|
|
|
|
int bytesread = 0;
|
|
|
|
uint8_t *ps2buf = av_malloc(len);
|
|
|
|
|
|
|
|
if (ps2buf) {
|
|
|
|
bytesread = avio_read(s->pb, ps2buf, len);
|
|
|
|
|
|
|
|
if (bytesread != len) {
|
|
|
|
avio_skip(s->pb, len - bytesread);
|
|
|
|
} else {
|
|
|
|
uint8_t *p = 0;
|
|
|
|
if (len >= 6)
|
|
|
|
p = memchr(ps2buf, 'S', len - 5);
|
|
|
|
|
|
|
|
if (p)
|
|
|
|
m->sofdec = !memcmp(p+1, "ofdec", 5);
|
|
|
|
|
|
|
|
m->sofdec -= !m->sofdec;
|
|
|
|
|
|
|
|
if (m->sofdec < 0) {
|
|
|
|
if (len == 980 && ps2buf[0] == 0) {
|
|
|
|
/* PCI structure? */
|
|
|
|
uint32_t startpts = AV_RB32(ps2buf + 0x0d);
|
|
|
|
uint32_t endpts = AV_RB32(ps2buf + 0x11);
|
|
|
|
uint8_t hours = ((ps2buf[0x19] >> 4) * 10) + (ps2buf[0x19] & 0x0f);
|
|
|
|
uint8_t mins = ((ps2buf[0x1a] >> 4) * 10) + (ps2buf[0x1a] & 0x0f);
|
|
|
|
uint8_t secs = ((ps2buf[0x1b] >> 4) * 10) + (ps2buf[0x1b] & 0x0f);
|
|
|
|
|
|
|
|
m->dvd = (hours <= 23 &&
|
|
|
|
mins <= 59 &&
|
|
|
|
secs <= 59 &&
|
|
|
|
(ps2buf[0x19] & 0x0f) < 10 &&
|
|
|
|
(ps2buf[0x1a] & 0x0f) < 10 &&
|
|
|
|
(ps2buf[0x1b] & 0x0f) < 10 &&
|
|
|
|
endpts >= startpts);
|
|
|
|
} else if (len == 1018 && ps2buf[0] == 1) {
|
|
|
|
/* DSI structure? */
|
|
|
|
uint8_t hours = ((ps2buf[0x1d] >> 4) * 10) + (ps2buf[0x1d] & 0x0f);
|
|
|
|
uint8_t mins = ((ps2buf[0x1e] >> 4) * 10) + (ps2buf[0x1e] & 0x0f);
|
|
|
|
uint8_t secs = ((ps2buf[0x1f] >> 4) * 10) + (ps2buf[0x1f] & 0x0f);
|
|
|
|
|
|
|
|
m->dvd = (hours <= 23 &&
|
|
|
|
mins <= 59 &&
|
|
|
|
secs <= 59 &&
|
|
|
|
(ps2buf[0x1d] & 0x0f) < 10 &&
|
|
|
|
(ps2buf[0x1e] & 0x0f) < 10 &&
|
|
|
|
(ps2buf[0x1f] & 0x0f) < 10);
|
|
|
|
}
|
|
|
|
}
|
2007-11-08 21:27:37 +00:00
|
|
|
}
|
2013-03-17 09:21:12 +00:00
|
|
|
|
|
|
|
av_free(ps2buf);
|
|
|
|
|
|
|
|
/* If this isn't a DVD packet or no memory
|
|
|
|
* could be allocated, just ignore it.
|
|
|
|
* If we did, move back to the start of the
|
|
|
|
* packet (plus 'length' field) */
|
|
|
|
if (!m->dvd || avio_skip(s->pb, -(len + 2)) < 0) {
|
|
|
|
/* Skip back failed.
|
|
|
|
* This packet will be lost but that can't be helped
|
|
|
|
* if we can't skip back
|
|
|
|
*/
|
|
|
|
goto redo;
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
/* No memory */
|
|
|
|
avio_skip(s->pb, len);
|
|
|
|
goto redo;
|
2007-11-08 21:27:37 +00:00
|
|
|
}
|
2013-03-17 09:21:12 +00:00
|
|
|
} else if (!m->dvd) {
|
|
|
|
int len = avio_rb16(s->pb);
|
|
|
|
avio_skip(s->pb, len);
|
|
|
|
goto redo;
|
2007-11-08 21:27:37 +00:00
|
|
|
}
|
2001-07-22 14:18:56 +00:00
|
|
|
}
|
2005-03-28 17:33:21 +00:00
|
|
|
if (startcode == PROGRAM_STREAM_MAP) {
|
2007-11-21 07:41:00 +00:00
|
|
|
mpegps_psm_parse(m, s->pb);
|
2005-03-28 17:33:21 +00:00
|
|
|
goto redo;
|
|
|
|
}
|
2005-12-17 18:14:38 +00:00
|
|
|
|
2001-07-22 14:18:56 +00:00
|
|
|
/* find matching stream */
|
|
|
|
if (!((startcode >= 0x1c0 && startcode <= 0x1df) ||
|
|
|
|
(startcode >= 0x1e0 && startcode <= 0x1ef) ||
|
2013-03-17 09:21:12 +00:00
|
|
|
(startcode == 0x1bd) ||
|
|
|
|
(startcode == PRIVATE_STREAM_2) ||
|
|
|
|
(startcode == 0x1fd)))
|
2001-07-22 14:18:56 +00:00
|
|
|
goto redo;
|
2003-11-10 18:47:52 +00:00
|
|
|
if (ppos) {
|
2011-03-03 19:11:45 +00:00
|
|
|
*ppos = avio_tell(s->pb) - 4;
|
2003-11-10 18:47:52 +00:00
|
|
|
}
|
2011-02-21 15:43:01 +00:00
|
|
|
len = avio_rb16(s->pb);
|
2007-01-17 10:45:59 +00:00
|
|
|
pts =
|
2002-10-21 15:57:21 +00:00
|
|
|
dts = AV_NOPTS_VALUE;
|
2013-03-17 09:21:12 +00:00
|
|
|
if (startcode != PRIVATE_STREAM_2)
|
|
|
|
{
|
2001-07-22 14:18:56 +00:00
|
|
|
/* stuffing */
|
2014-03-20 01:02:42 +00:00
|
|
|
for (;;) {
|
2003-11-10 18:47:52 +00:00
|
|
|
if (len < 1)
|
2007-01-17 10:19:10 +00:00
|
|
|
goto error_redo;
|
2011-02-21 15:43:01 +00:00
|
|
|
c = avio_r8(s->pb);
|
2001-07-22 14:18:56 +00:00
|
|
|
len--;
|
|
|
|
/* XXX: for mpeg1, should test only bit 7 */
|
2005-12-17 18:14:38 +00:00
|
|
|
if (c != 0xff)
|
2001-07-22 14:18:56 +00:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
if ((c & 0xc0) == 0x40) {
|
|
|
|
/* buffer scale & size */
|
2011-02-21 15:43:01 +00:00
|
|
|
avio_r8(s->pb);
|
2014-03-20 01:02:42 +00:00
|
|
|
c = avio_r8(s->pb);
|
2001-07-22 14:18:56 +00:00
|
|
|
len -= 2;
|
|
|
|
}
|
2007-01-17 10:55:01 +00:00
|
|
|
if ((c & 0xe0) == 0x20) {
|
2014-03-20 01:02:42 +00:00
|
|
|
dts =
|
|
|
|
pts = get_pts(s->pb, c);
|
2001-07-22 14:18:56 +00:00
|
|
|
len -= 4;
|
2014-03-20 01:02:42 +00:00
|
|
|
if (c & 0x10) {
|
|
|
|
dts = get_pts(s->pb, -1);
|
2007-01-17 10:55:01 +00:00
|
|
|
len -= 5;
|
|
|
|
}
|
2001-07-22 14:18:56 +00:00
|
|
|
} else if ((c & 0xc0) == 0x80) {
|
|
|
|
/* mpeg 2 PES */
|
2014-03-20 01:02:42 +00:00
|
|
|
flags = avio_r8(s->pb);
|
2011-02-21 15:43:01 +00:00
|
|
|
header_len = avio_r8(s->pb);
|
2014-03-20 01:02:42 +00:00
|
|
|
len -= 2;
|
2001-07-22 14:18:56 +00:00
|
|
|
if (header_len > len)
|
2007-01-17 10:19:10 +00:00
|
|
|
goto error_redo;
|
2007-01-17 12:06:31 +00:00
|
|
|
len -= header_len;
|
2007-01-17 10:55:01 +00:00
|
|
|
if (flags & 0x80) {
|
2014-03-20 01:02:42 +00:00
|
|
|
dts = pts = get_pts(s->pb, -1);
|
2001-07-22 14:18:56 +00:00
|
|
|
header_len -= 5;
|
2007-01-17 10:55:01 +00:00
|
|
|
if (flags & 0x40) {
|
2014-03-20 01:02:42 +00:00
|
|
|
dts = get_pts(s->pb, -1);
|
2007-01-17 10:55:01 +00:00
|
|
|
header_len -= 5;
|
|
|
|
}
|
2001-07-22 14:18:56 +00:00
|
|
|
}
|
2014-03-20 01:02:42 +00:00
|
|
|
if (flags & 0x3f && header_len == 0) {
|
2008-03-04 01:31:15 +00:00
|
|
|
flags &= 0xC0;
|
|
|
|
av_log(s, AV_LOG_WARNING, "Further flags set but no bytes left\n");
|
|
|
|
}
|
2007-02-06 19:14:16 +00:00
|
|
|
if (flags & 0x01) { /* PES extension */
|
2011-02-21 15:43:01 +00:00
|
|
|
pes_ext = avio_r8(s->pb);
|
2007-02-06 19:14:16 +00:00
|
|
|
header_len--;
|
2014-03-20 01:02:42 +00:00
|
|
|
/* Skip PES private data, program packet sequence counter
|
|
|
|
* and P-STD buffer */
|
|
|
|
skip = (pes_ext >> 4) & 0xb;
|
2007-02-06 19:14:16 +00:00
|
|
|
skip += skip & 0x9;
|
2014-03-20 01:02:42 +00:00
|
|
|
if (pes_ext & 0x40 || skip > header_len) {
|
2008-04-29 00:12:49 +00:00
|
|
|
av_log(s, AV_LOG_WARNING, "pes_ext %X is invalid\n", pes_ext);
|
2014-03-20 01:02:42 +00:00
|
|
|
pes_ext = skip = 0;
|
2008-04-29 00:12:49 +00:00
|
|
|
}
|
2011-03-15 08:14:38 +00:00
|
|
|
avio_skip(s->pb, skip);
|
2007-02-06 19:14:16 +00:00
|
|
|
header_len -= skip;
|
|
|
|
|
|
|
|
if (pes_ext & 0x01) { /* PES extension 2 */
|
2011-02-21 15:43:01 +00:00
|
|
|
ext2_len = avio_r8(s->pb);
|
2007-02-06 19:14:16 +00:00
|
|
|
header_len--;
|
|
|
|
if ((ext2_len & 0x7f) > 0) {
|
2011-02-21 15:43:01 +00:00
|
|
|
id_ext = avio_r8(s->pb);
|
2007-02-06 19:14:16 +00:00
|
|
|
if ((id_ext & 0x80) == 0)
|
|
|
|
startcode = ((startcode & 0xff) << 8) | id_ext;
|
|
|
|
header_len--;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
2014-03-20 01:02:42 +00:00
|
|
|
if (header_len < 0)
|
2007-01-17 12:06:31 +00:00
|
|
|
goto error_redo;
|
2011-03-15 08:14:38 +00:00
|
|
|
avio_skip(s->pb, header_len);
|
2014-03-20 01:02:42 +00:00
|
|
|
} else if (c != 0xf)
|
2004-04-23 21:02:01 +00:00
|
|
|
goto redo;
|
2013-03-17 09:21:12 +00:00
|
|
|
}
|
2004-04-23 21:02:01 +00:00
|
|
|
|
2012-07-31 17:20:00 +00:00
|
|
|
if (startcode == PRIVATE_STREAM_1) {
|
2011-02-21 15:43:01 +00:00
|
|
|
startcode = avio_r8(s->pb);
|
2001-07-22 14:18:56 +00:00
|
|
|
len--;
|
|
|
|
}
|
2014-03-20 01:02:42 +00:00
|
|
|
if (len < 0)
|
2007-01-17 10:44:57 +00:00
|
|
|
goto error_redo;
|
2014-03-20 01:02:42 +00:00
|
|
|
if (dts != AV_NOPTS_VALUE && ppos) {
|
2004-01-13 22:02:49 +00:00
|
|
|
int i;
|
2014-03-20 01:02:42 +00:00
|
|
|
for (i = 0; i < s->nb_streams; i++) {
|
|
|
|
if (startcode == s->streams[i]->id &&
|
|
|
|
s->pb->seekable /* index useless on streams anyway */) {
|
2008-01-13 13:33:37 +00:00
|
|
|
ff_reduce_index(s, i);
|
2014-03-20 01:02:42 +00:00
|
|
|
av_add_index_entry(s->streams[i], *ppos, dts, 0, 0,
|
|
|
|
AVINDEX_KEYFRAME /* FIXME keyframe? */);
|
2004-01-13 22:02:49 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
2005-12-17 18:14:38 +00:00
|
|
|
|
2003-11-10 18:47:52 +00:00
|
|
|
*pstart_code = startcode;
|
2014-03-20 01:02:42 +00:00
|
|
|
*ppts = pts;
|
|
|
|
*pdts = dts;
|
2003-11-10 18:47:52 +00:00
|
|
|
return len;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int mpegps_read_packet(AVFormatContext *s,
|
|
|
|
AVPacket *pkt)
|
|
|
|
{
|
2005-03-28 17:33:21 +00:00
|
|
|
MpegDemuxContext *m = s->priv_data;
|
2003-11-10 18:47:52 +00:00
|
|
|
AVStream *st;
|
2011-09-23 23:28:23 +00:00
|
|
|
int len, startcode, i, es_type, ret;
|
2014-06-03 02:46:04 +00:00
|
|
|
int lpcm_header_len = -1; //Init to suppress warning
|
2011-03-04 00:12:17 +00:00
|
|
|
int request_probe= 0;
|
2012-08-05 09:11:04 +00:00
|
|
|
enum AVCodecID codec_id = AV_CODEC_ID_NONE;
|
2010-03-30 23:30:55 +00:00
|
|
|
enum AVMediaType type;
|
2014-03-20 01:02:42 +00:00
|
|
|
int64_t pts, dts, dummy_pos; // dummy_pos is needed for the index building to work
|
2003-11-10 18:47:52 +00:00
|
|
|
|
2014-03-20 01:02:42 +00:00
|
|
|
redo:
|
2004-04-12 16:50:03 +00:00
|
|
|
len = mpegps_read_pes_header(s, &dummy_pos, &startcode, &pts, &dts);
|
2003-11-10 18:47:52 +00:00
|
|
|
if (len < 0)
|
|
|
|
return len;
|
2005-12-17 18:14:38 +00:00
|
|
|
|
2012-07-31 17:43:20 +00:00
|
|
|
if (startcode >= 0x80 && startcode <= 0xcf) {
|
2014-03-24 04:28:07 +00:00
|
|
|
if (len < 4)
|
2012-07-31 17:43:20 +00:00
|
|
|
goto skip;
|
|
|
|
|
|
|
|
/* audio: skip header */
|
|
|
|
avio_r8(s->pb);
|
2012-07-31 18:54:33 +00:00
|
|
|
lpcm_header_len = avio_rb16(s->pb);
|
2012-07-31 17:43:20 +00:00
|
|
|
len -= 3;
|
|
|
|
if (startcode >= 0xb0 && startcode <= 0xbf) {
|
|
|
|
/* MLP/TrueHD audio has a 4-byte header */
|
|
|
|
avio_r8(s->pb);
|
|
|
|
len--;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2001-07-22 14:18:56 +00:00
|
|
|
/* now find stream */
|
2014-03-20 01:02:42 +00:00
|
|
|
for (i = 0; i < s->nb_streams; i++) {
|
2001-07-22 14:18:56 +00:00
|
|
|
st = s->streams[i];
|
|
|
|
if (st->id == startcode)
|
|
|
|
goto found;
|
|
|
|
}
|
2005-03-28 17:33:21 +00:00
|
|
|
|
|
|
|
es_type = m->psm_es_type[startcode & 0xff];
|
2014-03-20 01:02:42 +00:00
|
|
|
if (es_type == STREAM_TYPE_VIDEO_MPEG1) {
|
2012-08-05 09:11:04 +00:00
|
|
|
codec_id = AV_CODEC_ID_MPEG2VIDEO;
|
2014-03-20 01:02:42 +00:00
|
|
|
type = AVMEDIA_TYPE_VIDEO;
|
|
|
|
} else if (es_type == STREAM_TYPE_VIDEO_MPEG2) {
|
2012-08-05 09:11:04 +00:00
|
|
|
codec_id = AV_CODEC_ID_MPEG2VIDEO;
|
2014-03-20 01:02:42 +00:00
|
|
|
type = AVMEDIA_TYPE_VIDEO;
|
|
|
|
} else if (es_type == STREAM_TYPE_AUDIO_MPEG1 ||
|
|
|
|
es_type == STREAM_TYPE_AUDIO_MPEG2) {
|
2012-08-05 09:11:04 +00:00
|
|
|
codec_id = AV_CODEC_ID_MP3;
|
2014-03-20 01:02:42 +00:00
|
|
|
type = AVMEDIA_TYPE_AUDIO;
|
|
|
|
} else if (es_type == STREAM_TYPE_AUDIO_AAC) {
|
2012-08-05 09:11:04 +00:00
|
|
|
codec_id = AV_CODEC_ID_AAC;
|
2014-03-20 01:02:42 +00:00
|
|
|
type = AVMEDIA_TYPE_AUDIO;
|
|
|
|
} else if (es_type == STREAM_TYPE_VIDEO_MPEG4) {
|
2012-08-05 09:11:04 +00:00
|
|
|
codec_id = AV_CODEC_ID_MPEG4;
|
2014-03-20 01:02:42 +00:00
|
|
|
type = AVMEDIA_TYPE_VIDEO;
|
|
|
|
} else if (es_type == STREAM_TYPE_VIDEO_H264) {
|
2012-08-05 09:11:04 +00:00
|
|
|
codec_id = AV_CODEC_ID_H264;
|
2014-03-20 01:02:42 +00:00
|
|
|
type = AVMEDIA_TYPE_VIDEO;
|
|
|
|
} else if (es_type == STREAM_TYPE_AUDIO_AC3) {
|
2012-08-05 09:11:04 +00:00
|
|
|
codec_id = AV_CODEC_ID_AC3;
|
2014-03-20 01:02:42 +00:00
|
|
|
type = AVMEDIA_TYPE_AUDIO;
|
2014-03-24 04:28:07 +00:00
|
|
|
} else if (m->imkh_cctv && es_type == 0x91) {
|
2013-03-27 00:48:07 +00:00
|
|
|
codec_id = AV_CODEC_ID_PCM_MULAW;
|
2014-03-24 04:28:07 +00:00
|
|
|
type = AVMEDIA_TYPE_AUDIO;
|
2005-03-28 17:33:21 +00:00
|
|
|
} else if (startcode >= 0x1e0 && startcode <= 0x1ef) {
|
2006-07-03 21:40:01 +00:00
|
|
|
static const unsigned char avs_seqh[4] = { 0, 0, 1, 0xb0 };
|
|
|
|
unsigned char buf[8];
|
2014-03-20 01:02:42 +00:00
|
|
|
|
2011-02-21 15:43:01 +00:00
|
|
|
avio_read(s->pb, buf, 8);
|
2011-02-28 13:57:54 +00:00
|
|
|
avio_seek(s->pb, -8, SEEK_CUR);
|
2014-03-20 01:02:42 +00:00
|
|
|
if (!memcmp(buf, avs_seqh, 4) && (buf[6] != 0 || buf[7] != 1))
|
2012-08-05 09:11:04 +00:00
|
|
|
codec_id = AV_CODEC_ID_CAVS;
|
2006-07-03 21:40:01 +00:00
|
|
|
else
|
2011-03-04 00:12:17 +00:00
|
|
|
request_probe= 1;
|
2010-03-30 23:30:55 +00:00
|
|
|
type = AVMEDIA_TYPE_VIDEO;
|
2013-03-17 09:21:12 +00:00
|
|
|
} else if (startcode == PRIVATE_STREAM_2) {
|
|
|
|
type = AVMEDIA_TYPE_DATA;
|
|
|
|
codec_id = AV_CODEC_ID_DVD_NAV;
|
2002-05-20 16:29:40 +00:00
|
|
|
} else if (startcode >= 0x1c0 && startcode <= 0x1df) {
|
2014-03-20 01:02:42 +00:00
|
|
|
type = AVMEDIA_TYPE_AUDIO;
|
2013-12-01 11:02:21 +00:00
|
|
|
if (m->sofdec > 0) {
|
|
|
|
codec_id = AV_CODEC_ID_ADPCM_ADX;
|
|
|
|
// Auto-detect AC-3
|
|
|
|
request_probe = 50;
|
|
|
|
} else {
|
|
|
|
codec_id = AV_CODEC_ID_MP2;
|
|
|
|
}
|
2005-05-20 13:10:09 +00:00
|
|
|
} else if (startcode >= 0x80 && startcode <= 0x87) {
|
2014-03-20 01:02:42 +00:00
|
|
|
type = AVMEDIA_TYPE_AUDIO;
|
2012-08-05 09:11:04 +00:00
|
|
|
codec_id = AV_CODEC_ID_AC3;
|
2014-03-20 01:02:42 +00:00
|
|
|
} else if ((startcode >= 0x88 && startcode <= 0x8f) ||
|
|
|
|
(startcode >= 0x98 && startcode <= 0x9f)) {
|
2007-02-06 19:14:16 +00:00
|
|
|
/* 0x90 - 0x97 is reserved for SDDS in DVD specs */
|
2014-03-20 01:02:42 +00:00
|
|
|
type = AVMEDIA_TYPE_AUDIO;
|
2012-08-05 09:11:04 +00:00
|
|
|
codec_id = AV_CODEC_ID_DTS;
|
2007-02-06 19:14:16 +00:00
|
|
|
} else if (startcode >= 0xa0 && startcode <= 0xaf) {
|
2014-03-20 01:02:42 +00:00
|
|
|
type = AVMEDIA_TYPE_AUDIO;
|
2014-03-24 04:28:07 +00:00
|
|
|
if (lpcm_header_len == 6) {
|
2012-08-07 20:45:46 +00:00
|
|
|
codec_id = AV_CODEC_ID_MLP;
|
2012-07-31 18:54:33 +00:00
|
|
|
} else {
|
2012-08-07 20:45:46 +00:00
|
|
|
codec_id = AV_CODEC_ID_PCM_DVD;
|
2012-07-31 18:54:33 +00:00
|
|
|
}
|
2007-02-06 19:14:16 +00:00
|
|
|
} else if (startcode >= 0xb0 && startcode <= 0xbf) {
|
2014-03-20 01:02:42 +00:00
|
|
|
type = AVMEDIA_TYPE_AUDIO;
|
2012-08-05 09:11:04 +00:00
|
|
|
codec_id = AV_CODEC_ID_TRUEHD;
|
2007-02-06 19:14:16 +00:00
|
|
|
} else if (startcode >= 0xc0 && startcode <= 0xcf) {
|
|
|
|
/* Used for both AC-3 and E-AC-3 in EVOB files */
|
2014-03-20 01:02:42 +00:00
|
|
|
type = AVMEDIA_TYPE_AUDIO;
|
2012-08-05 09:11:04 +00:00
|
|
|
codec_id = AV_CODEC_ID_AC3;
|
2005-06-03 14:01:49 +00:00
|
|
|
} else if (startcode >= 0x20 && startcode <= 0x3f) {
|
2014-03-20 01:02:42 +00:00
|
|
|
type = AVMEDIA_TYPE_SUBTITLE;
|
2012-08-05 09:11:04 +00:00
|
|
|
codec_id = AV_CODEC_ID_DVD_SUBTITLE;
|
2007-02-06 19:14:16 +00:00
|
|
|
} else if (startcode >= 0xfd55 && startcode <= 0xfd5f) {
|
2014-03-20 01:02:42 +00:00
|
|
|
type = AVMEDIA_TYPE_VIDEO;
|
2012-08-05 09:11:04 +00:00
|
|
|
codec_id = AV_CODEC_ID_VC1;
|
2002-05-20 16:29:40 +00:00
|
|
|
} else {
|
2014-03-20 01:02:42 +00:00
|
|
|
skip:
|
2002-05-20 16:29:40 +00:00
|
|
|
/* skip packet */
|
2011-03-15 08:14:38 +00:00
|
|
|
avio_skip(s->pb, len);
|
2002-05-20 16:29:40 +00:00
|
|
|
goto redo;
|
|
|
|
}
|
2002-10-04 15:46:59 +00:00
|
|
|
/* no stream found: add a new stream */
|
2011-06-18 09:43:24 +00:00
|
|
|
st = avformat_new_stream(s, NULL);
|
2005-12-17 18:14:38 +00:00
|
|
|
if (!st)
|
2002-10-04 15:46:59 +00:00
|
|
|
goto skip;
|
2014-03-20 01:02:42 +00:00
|
|
|
st->id = startcode;
|
2005-07-17 22:24:36 +00:00
|
|
|
st->codec->codec_type = type;
|
2014-03-20 01:02:42 +00:00
|
|
|
st->codec->codec_id = codec_id;
|
2013-03-27 00:48:07 +00:00
|
|
|
if (st->codec->codec_id == AV_CODEC_ID_PCM_MULAW) {
|
|
|
|
st->codec->channels = 1;
|
|
|
|
st->codec->channel_layout = AV_CH_LAYOUT_MONO;
|
|
|
|
st->codec->sample_rate = 8000;
|
|
|
|
}
|
2011-03-04 00:12:17 +00:00
|
|
|
st->request_probe = request_probe;
|
2014-03-20 01:02:42 +00:00
|
|
|
st->need_parsing = AVSTREAM_PARSE_FULL;
|
|
|
|
|
|
|
|
found:
|
|
|
|
if (st->discard >= AVDISCARD_ALL)
|
2005-01-22 13:36:02 +00:00
|
|
|
goto skip;
|
2012-07-31 17:20:00 +00:00
|
|
|
if (startcode >= 0xa0 && startcode <= 0xaf) {
|
2013-01-17 16:19:08 +00:00
|
|
|
if (lpcm_header_len == 6 && st->codec->codec_id == AV_CODEC_ID_MLP) {
|
2012-07-31 18:54:33 +00:00
|
|
|
if (len < 6)
|
|
|
|
goto skip;
|
|
|
|
avio_skip(s->pb, 6);
|
|
|
|
len -=6;
|
|
|
|
}
|
2003-01-31 17:04:46 +00:00
|
|
|
}
|
2011-10-08 00:02:36 +00:00
|
|
|
ret = av_get_packet(s->pb, pkt, len);
|
2014-03-20 01:02:42 +00:00
|
|
|
|
|
|
|
pkt->pts = pts;
|
|
|
|
pkt->dts = dts;
|
|
|
|
pkt->pos = dummy_pos;
|
2002-05-20 16:29:40 +00:00
|
|
|
pkt->stream_index = st->index;
|
2011-06-02 18:40:09 +00:00
|
|
|
av_dlog(s, "%d: pts=%0.3f dts=%0.3f size=%d\n",
|
2011-04-29 15:27:01 +00:00
|
|
|
pkt->stream_index, pkt->pts / 90000.0, pkt->dts / 90000.0,
|
|
|
|
pkt->size);
|
2004-06-19 03:59:34 +00:00
|
|
|
|
2011-09-23 23:28:23 +00:00
|
|
|
return (ret < 0) ? ret : 0;
|
2001-07-22 14:18:56 +00:00
|
|
|
}
|
|
|
|
|
2005-12-17 18:14:38 +00:00
|
|
|
static int64_t mpegps_read_dts(AVFormatContext *s, int stream_index,
|
2004-04-12 16:50:03 +00:00
|
|
|
int64_t *ppos, int64_t pos_limit)
|
2003-11-10 18:47:52 +00:00
|
|
|
{
|
|
|
|
int len, startcode;
|
|
|
|
int64_t pos, pts, dts;
|
|
|
|
|
|
|
|
pos = *ppos;
|
2011-02-28 13:57:54 +00:00
|
|
|
if (avio_seek(s->pb, pos, SEEK_SET) < 0)
|
2008-05-29 09:50:17 +00:00
|
|
|
return AV_NOPTS_VALUE;
|
|
|
|
|
2014-03-20 01:02:42 +00:00
|
|
|
for (;;) {
|
2004-04-12 16:50:03 +00:00
|
|
|
len = mpegps_read_pes_header(s, &pos, &startcode, &pts, &dts);
|
2003-11-10 18:47:52 +00:00
|
|
|
if (len < 0) {
|
2011-06-07 11:18:12 +00:00
|
|
|
av_dlog(s, "none (ret=%d)\n", len);
|
2003-11-10 18:47:52 +00:00
|
|
|
return AV_NOPTS_VALUE;
|
|
|
|
}
|
2005-12-17 18:14:38 +00:00
|
|
|
if (startcode == s->streams[stream_index]->id &&
|
2003-11-10 18:47:52 +00:00
|
|
|
dts != AV_NOPTS_VALUE) {
|
|
|
|
break;
|
|
|
|
}
|
2011-03-15 08:14:38 +00:00
|
|
|
avio_skip(s->pb, len);
|
2003-11-10 18:47:52 +00:00
|
|
|
}
|
2011-06-07 11:18:12 +00:00
|
|
|
av_dlog(s, "pos=0x%"PRIx64" dts=0x%"PRIx64" %0.3f\n",
|
|
|
|
pos, dts, dts / 90000.0);
|
2003-11-10 18:47:52 +00:00
|
|
|
*ppos = pos;
|
2004-05-23 16:26:12 +00:00
|
|
|
return dts;
|
2003-11-10 18:47:52 +00:00
|
|
|
}
|
|
|
|
|
2011-01-25 22:03:28 +00:00
|
|
|
AVInputFormat ff_mpegps_demuxer = {
|
2011-07-16 20:18:12 +00:00
|
|
|
.name = "mpeg",
|
2012-07-24 01:23:48 +00:00
|
|
|
.long_name = NULL_IF_CONFIG_SMALL("MPEG-PS (MPEG-2 Program Stream)"),
|
2011-07-16 20:18:12 +00:00
|
|
|
.priv_data_size = sizeof(MpegDemuxContext),
|
|
|
|
.read_probe = mpegps_probe,
|
|
|
|
.read_header = mpegps_read_header,
|
|
|
|
.read_packet = mpegps_read_packet,
|
|
|
|
.read_timestamp = mpegps_read_dts,
|
2012-04-06 14:50:48 +00:00
|
|
|
.flags = AVFMT_SHOW_IDS | AVFMT_TS_DISCONT,
|
2001-07-22 14:18:56 +00:00
|
|
|
};
|
2012-09-03 00:51:00 +00:00
|
|
|
|
|
|
|
#if CONFIG_VOBSUB_DEMUXER
|
|
|
|
|
|
|
|
#define REF_STRING "# VobSub index file,"
|
2014-05-24 09:03:23 +00:00
|
|
|
#define MAX_LINE_SIZE 2048
|
2012-09-03 00:51:00 +00:00
|
|
|
|
|
|
|
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)
|
|
|
|
{
|
2013-01-02 08:31:07 +00:00
|
|
|
int i, ret = 0, header_parsed = 0, langidx = 0;
|
2012-09-03 00:51:00 +00:00
|
|
|
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;
|
2014-05-24 09:03:23 +00:00
|
|
|
int stream_id = -1;
|
|
|
|
char id[64] = {0};
|
|
|
|
char alt[MAX_LINE_SIZE] = {0};
|
2014-10-25 14:28:41 +00:00
|
|
|
AVInputFormat *iformat;
|
2012-09-03 00:51:00 +00:00
|
|
|
|
|
|
|
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);
|
2014-10-23 14:07:00 +00:00
|
|
|
|
2014-11-16 18:17:34 +00:00
|
|
|
if (!(iformat = av_find_input_format("mpeg"))) {
|
|
|
|
ret = AVERROR_DEMUXER_NOT_FOUND;
|
|
|
|
goto end;
|
|
|
|
}
|
2014-10-25 14:28:41 +00:00
|
|
|
|
2014-10-23 14:07:00 +00:00
|
|
|
vobsub->sub_ctx = avformat_alloc_context();
|
2014-11-16 18:17:34 +00:00
|
|
|
if (!vobsub->sub_ctx) {
|
|
|
|
ret = AVERROR(ENOMEM);
|
|
|
|
goto end;
|
|
|
|
}
|
2014-10-23 14:07:00 +00:00
|
|
|
|
2014-10-24 17:23:23 +00:00
|
|
|
if ((ret = ff_copy_whitelists(vobsub->sub_ctx, s)) < 0)
|
|
|
|
goto end;
|
2014-10-23 14:07:00 +00:00
|
|
|
|
2014-10-25 14:28:41 +00:00
|
|
|
ret = avformat_open_input(&vobsub->sub_ctx, sub_name, iformat, NULL);
|
2012-09-03 00:51:00 +00:00
|
|
|
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);
|
2014-08-07 20:12:41 +00:00
|
|
|
while (!avio_feof(s->pb)) {
|
2014-05-24 09:03:23 +00:00
|
|
|
char line[MAX_LINE_SIZE];
|
2012-09-03 00:51:00 +00:00
|
|
|
int len = ff_get_line(s->pb, line, sizeof(line));
|
|
|
|
|
|
|
|
if (!len)
|
|
|
|
break;
|
|
|
|
|
|
|
|
line[strcspn(line, "\r\n")] = 0;
|
|
|
|
|
|
|
|
if (!strncmp(line, "id:", 3)) {
|
2014-05-24 09:03:23 +00:00
|
|
|
if (sscanf(line, "id: %63[^,], index: %u", id, &stream_id) != 2) {
|
2012-09-03 00:51:00 +00:00
|
|
|
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;
|
|
|
|
}
|
|
|
|
|
avformat/vobsub: fix several issues.
Here is an extract of fate-samples/sub/vobsub.idx, with an additional
text at the end of each line to better identify each bitmap:
timestamp: 00:04:55:445, filepos: 00001b000 Ace!
timestamp: 00:05:00:049, filepos: 00001b800 Wake up, honey!
timestamp: 00:05:02:018, filepos: 00001c800 I gotta go to work.
timestamp: 00:05:02:035, filepos: 00001d000 <???>
timestamp: 00:05:04:203, filepos: 00001d800 Look after Clayton, okay?
timestamp: 00:05:05:947, filepos: 00001e800 I'll be back tonight.
timestamp: 00:05:07:957, filepos: 00001f800 Bye! Love you.
timestamp: 00:05:21:295, filepos: 000020800 Hey, Ace! What's up?
timestamp: 00:05:23:356, filepos: 000021800 Hey, how's it going?
timestamp: 00:05:24:640, filepos: 000022800 Remember what today is? The 3rd!
timestamp: 00:05:27:193, filepos: 000023800 Look over there!
timestamp: 00:05:28:369, filepos: 000024800 Where are they going?
timestamp: 00:05:28:361, filepos: 000025000 <???>
timestamp: 00:05:29:946, filepos: 000025800 Let's go see.
timestamp: 00:05:31:230, filepos: 000026000 I can't, man. I got Clayton.
Note the two "<???>": they are basically split subtitles (with the
previous one), which the dvdsub decoder is now supposed to reconstruct
with a previous commit. But also note that while the first chunk has
increasing timestamps,
timestamp: 00:05:02:018, filepos: 00001c800
timestamp: 00:05:02:035, filepos: 00001d000
...it's not the case of the second one (and this is not an exception in the
original file):
timestamp: 00:05:28:369, filepos: 000024800
timestamp: 00:05:28:361, filepos: 000025000
For the dvdsub decoder, they need to be "filepos'ed" ordered, but the
FFDemuxSubtitlesQueue is timestamps ordered, which is the reason of the
introduction of a sub sort method in the context, to allow giving
priority to the position, and then the timestamps. With that change, the
dvdsub decoder get fed with ordered packets.
Now the packet size estimation was also broken: the filepos differences
in the vobsub index defines the full data read between two subtitles
chunks, and it is necessary to take into account what is read by the
mpegps_read_pes_header() function since the length returned by that
function doesn't count the size of the data it reads. This is fixed with
the introduction of total_read, and {old,new}_pos. By doing this change,
we can drop the unreliable len16 heuristic and simplify the whole loop.
Note that mpegps_read_pes_header() often read more than one PES packet
(typically in one call it can read 0x1ba and 0x1be chunk along with the
relevant 0x1bd packet), which triggers the "total_read + pkt_size >
psize" check. This is an expected behaviour, which could be avoided by
having a more chunked version of mpegps_read_pes_header().
The latest change is the extraction of each stream into its own
subtitles queue. If we don't do this, the maximum size for a subtitle
chunk is broken, and the previous changes can not work. Having each
stream in a different queue requires some little adjustments in the
seek code of the demuxer.
This commit is only meaningful as a whole change and can not be easily
split. The FATE test changes because it uses the vobsub demuxer.
2013-09-29 20:05:14 +00:00
|
|
|
if (stream_id >= FF_ARRAY_ELEMS(vobsub->q)) {
|
|
|
|
av_log(s, AV_LOG_ERROR, "Maximum number of subtitles streams reached\n");
|
|
|
|
ret = AVERROR(EINVAL);
|
|
|
|
goto end;
|
|
|
|
}
|
|
|
|
|
2012-09-03 00:51:00 +00:00
|
|
|
header_parsed = 1;
|
2014-05-24 09:03:23 +00:00
|
|
|
alt[0] = '\0';
|
|
|
|
/* We do not create the stream immediately to avoid adding empty
|
|
|
|
* streams. See the following timestamp entry. */
|
|
|
|
|
|
|
|
av_log(s, AV_LOG_DEBUG, "IDX stream[%d] id=%s\n", stream_id, id);
|
2012-09-03 00:51:00 +00:00
|
|
|
|
2014-05-24 09:03:23 +00:00
|
|
|
} else if (!strncmp(line, "timestamp:", 10)) {
|
2012-09-03 00:51:00 +00:00
|
|
|
AVPacket *sub;
|
|
|
|
int hh, mm, ss, ms;
|
|
|
|
int64_t pos, timestamp;
|
|
|
|
const char *p = line + 10;
|
|
|
|
|
2014-05-24 09:03:23 +00:00
|
|
|
if (stream_id == -1) {
|
avformat/vobsub: fix several issues.
Here is an extract of fate-samples/sub/vobsub.idx, with an additional
text at the end of each line to better identify each bitmap:
timestamp: 00:04:55:445, filepos: 00001b000 Ace!
timestamp: 00:05:00:049, filepos: 00001b800 Wake up, honey!
timestamp: 00:05:02:018, filepos: 00001c800 I gotta go to work.
timestamp: 00:05:02:035, filepos: 00001d000 <???>
timestamp: 00:05:04:203, filepos: 00001d800 Look after Clayton, okay?
timestamp: 00:05:05:947, filepos: 00001e800 I'll be back tonight.
timestamp: 00:05:07:957, filepos: 00001f800 Bye! Love you.
timestamp: 00:05:21:295, filepos: 000020800 Hey, Ace! What's up?
timestamp: 00:05:23:356, filepos: 000021800 Hey, how's it going?
timestamp: 00:05:24:640, filepos: 000022800 Remember what today is? The 3rd!
timestamp: 00:05:27:193, filepos: 000023800 Look over there!
timestamp: 00:05:28:369, filepos: 000024800 Where are they going?
timestamp: 00:05:28:361, filepos: 000025000 <???>
timestamp: 00:05:29:946, filepos: 000025800 Let's go see.
timestamp: 00:05:31:230, filepos: 000026000 I can't, man. I got Clayton.
Note the two "<???>": they are basically split subtitles (with the
previous one), which the dvdsub decoder is now supposed to reconstruct
with a previous commit. But also note that while the first chunk has
increasing timestamps,
timestamp: 00:05:02:018, filepos: 00001c800
timestamp: 00:05:02:035, filepos: 00001d000
...it's not the case of the second one (and this is not an exception in the
original file):
timestamp: 00:05:28:369, filepos: 000024800
timestamp: 00:05:28:361, filepos: 000025000
For the dvdsub decoder, they need to be "filepos'ed" ordered, but the
FFDemuxSubtitlesQueue is timestamps ordered, which is the reason of the
introduction of a sub sort method in the context, to allow giving
priority to the position, and then the timestamps. With that change, the
dvdsub decoder get fed with ordered packets.
Now the packet size estimation was also broken: the filepos differences
in the vobsub index defines the full data read between two subtitles
chunks, and it is necessary to take into account what is read by the
mpegps_read_pes_header() function since the length returned by that
function doesn't count the size of the data it reads. This is fixed with
the introduction of total_read, and {old,new}_pos. By doing this change,
we can drop the unreliable len16 heuristic and simplify the whole loop.
Note that mpegps_read_pes_header() often read more than one PES packet
(typically in one call it can read 0x1ba and 0x1be chunk along with the
relevant 0x1bd packet), which triggers the "total_read + pkt_size >
psize" check. This is an expected behaviour, which could be avoided by
having a more chunked version of mpegps_read_pes_header().
The latest change is the extraction of each stream into its own
subtitles queue. If we don't do this, the maximum size for a subtitle
chunk is broken, and the previous changes can not work. Having each
stream in a different queue requires some little adjustments in the
seek code of the demuxer.
This commit is only meaningful as a whole change and can not be easily
split. The FATE test changes because it uses the vobsub demuxer.
2013-09-29 20:05:14 +00:00
|
|
|
av_log(s, AV_LOG_ERROR, "Timestamp declared before any stream\n");
|
|
|
|
ret = AVERROR_INVALIDDATA;
|
|
|
|
goto end;
|
|
|
|
}
|
|
|
|
|
2014-05-24 09:03:23 +00:00
|
|
|
if (!st || st->id != stream_id) {
|
|
|
|
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;
|
|
|
|
avpriv_set_pts_info(st, 64, 1, 1000);
|
|
|
|
av_dict_set(&st->metadata, "language", id, 0);
|
|
|
|
if (alt[0])
|
|
|
|
av_dict_set(&st->metadata, "title", alt, 0);
|
|
|
|
}
|
|
|
|
|
2013-04-10 07:52:08 +00:00
|
|
|
if (sscanf(p, "%02d:%02d:%02d:%03d, filepos: %"SCNx64,
|
2012-09-03 00:51:00 +00:00
|
|
|
&hh, &mm, &ss, &ms, &pos) != 5) {
|
|
|
|
av_log(s, AV_LOG_ERROR, "Unable to parse timestamp line '%s', "
|
|
|
|
"abort parsing\n", line);
|
2014-05-24 09:03:23 +00:00
|
|
|
ret = AVERROR_INVALIDDATA;
|
|
|
|
goto end;
|
2012-09-03 00:51:00 +00:00
|
|
|
}
|
|
|
|
timestamp = (hh*3600LL + mm*60LL + ss) * 1000LL + ms + delay;
|
2014-05-01 14:18:12 +00:00
|
|
|
timestamp = av_rescale_q(timestamp, av_make_q(1, 1000), st->time_base);
|
2012-09-03 00:51:00 +00:00
|
|
|
|
avformat/vobsub: fix several issues.
Here is an extract of fate-samples/sub/vobsub.idx, with an additional
text at the end of each line to better identify each bitmap:
timestamp: 00:04:55:445, filepos: 00001b000 Ace!
timestamp: 00:05:00:049, filepos: 00001b800 Wake up, honey!
timestamp: 00:05:02:018, filepos: 00001c800 I gotta go to work.
timestamp: 00:05:02:035, filepos: 00001d000 <???>
timestamp: 00:05:04:203, filepos: 00001d800 Look after Clayton, okay?
timestamp: 00:05:05:947, filepos: 00001e800 I'll be back tonight.
timestamp: 00:05:07:957, filepos: 00001f800 Bye! Love you.
timestamp: 00:05:21:295, filepos: 000020800 Hey, Ace! What's up?
timestamp: 00:05:23:356, filepos: 000021800 Hey, how's it going?
timestamp: 00:05:24:640, filepos: 000022800 Remember what today is? The 3rd!
timestamp: 00:05:27:193, filepos: 000023800 Look over there!
timestamp: 00:05:28:369, filepos: 000024800 Where are they going?
timestamp: 00:05:28:361, filepos: 000025000 <???>
timestamp: 00:05:29:946, filepos: 000025800 Let's go see.
timestamp: 00:05:31:230, filepos: 000026000 I can't, man. I got Clayton.
Note the two "<???>": they are basically split subtitles (with the
previous one), which the dvdsub decoder is now supposed to reconstruct
with a previous commit. But also note that while the first chunk has
increasing timestamps,
timestamp: 00:05:02:018, filepos: 00001c800
timestamp: 00:05:02:035, filepos: 00001d000
...it's not the case of the second one (and this is not an exception in the
original file):
timestamp: 00:05:28:369, filepos: 000024800
timestamp: 00:05:28:361, filepos: 000025000
For the dvdsub decoder, they need to be "filepos'ed" ordered, but the
FFDemuxSubtitlesQueue is timestamps ordered, which is the reason of the
introduction of a sub sort method in the context, to allow giving
priority to the position, and then the timestamps. With that change, the
dvdsub decoder get fed with ordered packets.
Now the packet size estimation was also broken: the filepos differences
in the vobsub index defines the full data read between two subtitles
chunks, and it is necessary to take into account what is read by the
mpegps_read_pes_header() function since the length returned by that
function doesn't count the size of the data it reads. This is fixed with
the introduction of total_read, and {old,new}_pos. By doing this change,
we can drop the unreliable len16 heuristic and simplify the whole loop.
Note that mpegps_read_pes_header() often read more than one PES packet
(typically in one call it can read 0x1ba and 0x1be chunk along with the
relevant 0x1bd packet), which triggers the "total_read + pkt_size >
psize" check. This is an expected behaviour, which could be avoided by
having a more chunked version of mpegps_read_pes_header().
The latest change is the extraction of each stream into its own
subtitles queue. If we don't do this, the maximum size for a subtitle
chunk is broken, and the previous changes can not work. Having each
stream in a different queue requires some little adjustments in the
seek code of the demuxer.
This commit is only meaningful as a whole change and can not be easily
split. The FATE test changes because it uses the vobsub demuxer.
2013-09-29 20:05:14 +00:00
|
|
|
sub = ff_subtitles_queue_insert(&vobsub->q[s->nb_streams - 1], "", 0, 0);
|
2012-09-03 00:51:00 +00:00
|
|
|
if (!sub) {
|
|
|
|
ret = AVERROR(ENOMEM);
|
|
|
|
goto end;
|
|
|
|
}
|
|
|
|
sub->pos = pos;
|
|
|
|
sub->pts = timestamp;
|
|
|
|
sub->stream_index = s->nb_streams - 1;
|
|
|
|
|
2014-05-24 09:03:23 +00:00
|
|
|
} else if (!strncmp(line, "alt:", 4)) {
|
2012-09-03 00:51:00 +00:00
|
|
|
const char *p = line + 4;
|
|
|
|
|
|
|
|
while (*p == ' ')
|
|
|
|
p++;
|
2014-09-13 13:15:32 +00:00
|
|
|
av_log(s, AV_LOG_DEBUG, "IDX stream[%d] name=%s\n", stream_id, p);
|
2014-05-24 09:03:23 +00:00
|
|
|
av_strlcpy(alt, p, sizeof(alt));
|
2012-09-03 00:51:00 +00:00
|
|
|
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;
|
|
|
|
|
avformat/vobsub: fix several issues.
Here is an extract of fate-samples/sub/vobsub.idx, with an additional
text at the end of each line to better identify each bitmap:
timestamp: 00:04:55:445, filepos: 00001b000 Ace!
timestamp: 00:05:00:049, filepos: 00001b800 Wake up, honey!
timestamp: 00:05:02:018, filepos: 00001c800 I gotta go to work.
timestamp: 00:05:02:035, filepos: 00001d000 <???>
timestamp: 00:05:04:203, filepos: 00001d800 Look after Clayton, okay?
timestamp: 00:05:05:947, filepos: 00001e800 I'll be back tonight.
timestamp: 00:05:07:957, filepos: 00001f800 Bye! Love you.
timestamp: 00:05:21:295, filepos: 000020800 Hey, Ace! What's up?
timestamp: 00:05:23:356, filepos: 000021800 Hey, how's it going?
timestamp: 00:05:24:640, filepos: 000022800 Remember what today is? The 3rd!
timestamp: 00:05:27:193, filepos: 000023800 Look over there!
timestamp: 00:05:28:369, filepos: 000024800 Where are they going?
timestamp: 00:05:28:361, filepos: 000025000 <???>
timestamp: 00:05:29:946, filepos: 000025800 Let's go see.
timestamp: 00:05:31:230, filepos: 000026000 I can't, man. I got Clayton.
Note the two "<???>": they are basically split subtitles (with the
previous one), which the dvdsub decoder is now supposed to reconstruct
with a previous commit. But also note that while the first chunk has
increasing timestamps,
timestamp: 00:05:02:018, filepos: 00001c800
timestamp: 00:05:02:035, filepos: 00001d000
...it's not the case of the second one (and this is not an exception in the
original file):
timestamp: 00:05:28:369, filepos: 000024800
timestamp: 00:05:28:361, filepos: 000025000
For the dvdsub decoder, they need to be "filepos'ed" ordered, but the
FFDemuxSubtitlesQueue is timestamps ordered, which is the reason of the
introduction of a sub sort method in the context, to allow giving
priority to the position, and then the timestamps. With that change, the
dvdsub decoder get fed with ordered packets.
Now the packet size estimation was also broken: the filepos differences
in the vobsub index defines the full data read between two subtitles
chunks, and it is necessary to take into account what is read by the
mpegps_read_pes_header() function since the length returned by that
function doesn't count the size of the data it reads. This is fixed with
the introduction of total_read, and {old,new}_pos. By doing this change,
we can drop the unreliable len16 heuristic and simplify the whole loop.
Note that mpegps_read_pes_header() often read more than one PES packet
(typically in one call it can read 0x1ba and 0x1be chunk along with the
relevant 0x1bd packet), which triggers the "total_read + pkt_size >
psize" check. This is an expected behaviour, which could be avoided by
having a more chunked version of mpegps_read_pes_header().
The latest change is the extraction of each stream into its own
subtitles queue. If we don't do this, the maximum size for a subtitle
chunk is broken, and the previous changes can not work. Having each
stream in a different queue requires some little adjustments in the
seek code of the demuxer.
This commit is only meaningful as a whole change and can not be easily
split. The FATE test changes because it uses the vobsub demuxer.
2013-09-29 20:05:14 +00:00
|
|
|
for (i = 0; i < s->nb_streams; i++) {
|
|
|
|
vobsub->q[i].sort = SUB_SORT_POS_TS;
|
|
|
|
ff_subtitles_queue_finalize(&vobsub->q[i]);
|
|
|
|
}
|
2012-09-03 00:51:00 +00:00
|
|
|
|
|
|
|
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);
|
2013-01-02 08:31:07 +00:00
|
|
|
sub_st->codec->extradata_size = header.len;
|
2012-09-03 00:51:00 +00:00
|
|
|
}
|
|
|
|
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;
|
avformat/vobsub: fix several issues.
Here is an extract of fate-samples/sub/vobsub.idx, with an additional
text at the end of each line to better identify each bitmap:
timestamp: 00:04:55:445, filepos: 00001b000 Ace!
timestamp: 00:05:00:049, filepos: 00001b800 Wake up, honey!
timestamp: 00:05:02:018, filepos: 00001c800 I gotta go to work.
timestamp: 00:05:02:035, filepos: 00001d000 <???>
timestamp: 00:05:04:203, filepos: 00001d800 Look after Clayton, okay?
timestamp: 00:05:05:947, filepos: 00001e800 I'll be back tonight.
timestamp: 00:05:07:957, filepos: 00001f800 Bye! Love you.
timestamp: 00:05:21:295, filepos: 000020800 Hey, Ace! What's up?
timestamp: 00:05:23:356, filepos: 000021800 Hey, how's it going?
timestamp: 00:05:24:640, filepos: 000022800 Remember what today is? The 3rd!
timestamp: 00:05:27:193, filepos: 000023800 Look over there!
timestamp: 00:05:28:369, filepos: 000024800 Where are they going?
timestamp: 00:05:28:361, filepos: 000025000 <???>
timestamp: 00:05:29:946, filepos: 000025800 Let's go see.
timestamp: 00:05:31:230, filepos: 000026000 I can't, man. I got Clayton.
Note the two "<???>": they are basically split subtitles (with the
previous one), which the dvdsub decoder is now supposed to reconstruct
with a previous commit. But also note that while the first chunk has
increasing timestamps,
timestamp: 00:05:02:018, filepos: 00001c800
timestamp: 00:05:02:035, filepos: 00001d000
...it's not the case of the second one (and this is not an exception in the
original file):
timestamp: 00:05:28:369, filepos: 000024800
timestamp: 00:05:28:361, filepos: 000025000
For the dvdsub decoder, they need to be "filepos'ed" ordered, but the
FFDemuxSubtitlesQueue is timestamps ordered, which is the reason of the
introduction of a sub sort method in the context, to allow giving
priority to the position, and then the timestamps. With that change, the
dvdsub decoder get fed with ordered packets.
Now the packet size estimation was also broken: the filepos differences
in the vobsub index defines the full data read between two subtitles
chunks, and it is necessary to take into account what is read by the
mpegps_read_pes_header() function since the length returned by that
function doesn't count the size of the data it reads. This is fixed with
the introduction of total_read, and {old,new}_pos. By doing this change,
we can drop the unreliable len16 heuristic and simplify the whole loop.
Note that mpegps_read_pes_header() often read more than one PES packet
(typically in one call it can read 0x1ba and 0x1be chunk along with the
relevant 0x1bd packet), which triggers the "total_read + pkt_size >
psize" check. This is an expected behaviour, which could be avoided by
having a more chunked version of mpegps_read_pes_header().
The latest change is the extraction of each stream into its own
subtitles queue. If we don't do this, the maximum size for a subtitle
chunk is broken, and the previous changes can not work. Having each
stream in a different queue requires some little adjustments in the
seek code of the demuxer.
This commit is only meaningful as a whole change and can not be easily
split. The FATE test changes because it uses the vobsub demuxer.
2013-09-29 20:05:14 +00:00
|
|
|
FFDemuxSubtitlesQueue *q;
|
2012-09-03 00:51:00 +00:00
|
|
|
AVIOContext *pb = vobsub->sub_ctx->pb;
|
avformat/vobsub: fix several issues.
Here is an extract of fate-samples/sub/vobsub.idx, with an additional
text at the end of each line to better identify each bitmap:
timestamp: 00:04:55:445, filepos: 00001b000 Ace!
timestamp: 00:05:00:049, filepos: 00001b800 Wake up, honey!
timestamp: 00:05:02:018, filepos: 00001c800 I gotta go to work.
timestamp: 00:05:02:035, filepos: 00001d000 <???>
timestamp: 00:05:04:203, filepos: 00001d800 Look after Clayton, okay?
timestamp: 00:05:05:947, filepos: 00001e800 I'll be back tonight.
timestamp: 00:05:07:957, filepos: 00001f800 Bye! Love you.
timestamp: 00:05:21:295, filepos: 000020800 Hey, Ace! What's up?
timestamp: 00:05:23:356, filepos: 000021800 Hey, how's it going?
timestamp: 00:05:24:640, filepos: 000022800 Remember what today is? The 3rd!
timestamp: 00:05:27:193, filepos: 000023800 Look over there!
timestamp: 00:05:28:369, filepos: 000024800 Where are they going?
timestamp: 00:05:28:361, filepos: 000025000 <???>
timestamp: 00:05:29:946, filepos: 000025800 Let's go see.
timestamp: 00:05:31:230, filepos: 000026000 I can't, man. I got Clayton.
Note the two "<???>": they are basically split subtitles (with the
previous one), which the dvdsub decoder is now supposed to reconstruct
with a previous commit. But also note that while the first chunk has
increasing timestamps,
timestamp: 00:05:02:018, filepos: 00001c800
timestamp: 00:05:02:035, filepos: 00001d000
...it's not the case of the second one (and this is not an exception in the
original file):
timestamp: 00:05:28:369, filepos: 000024800
timestamp: 00:05:28:361, filepos: 000025000
For the dvdsub decoder, they need to be "filepos'ed" ordered, but the
FFDemuxSubtitlesQueue is timestamps ordered, which is the reason of the
introduction of a sub sort method in the context, to allow giving
priority to the position, and then the timestamps. With that change, the
dvdsub decoder get fed with ordered packets.
Now the packet size estimation was also broken: the filepos differences
in the vobsub index defines the full data read between two subtitles
chunks, and it is necessary to take into account what is read by the
mpegps_read_pes_header() function since the length returned by that
function doesn't count the size of the data it reads. This is fixed with
the introduction of total_read, and {old,new}_pos. By doing this change,
we can drop the unreliable len16 heuristic and simplify the whole loop.
Note that mpegps_read_pes_header() often read more than one PES packet
(typically in one call it can read 0x1ba and 0x1be chunk along with the
relevant 0x1bd packet), which triggers the "total_read + pkt_size >
psize" check. This is an expected behaviour, which could be avoided by
having a more chunked version of mpegps_read_pes_header().
The latest change is the extraction of each stream into its own
subtitles queue. If we don't do this, the maximum size for a subtitle
chunk is broken, and the previous changes can not work. Having each
stream in a different queue requires some little adjustments in the
seek code of the demuxer.
This commit is only meaningful as a whole change and can not be easily
split. The FATE test changes because it uses the vobsub demuxer.
2013-09-29 20:05:14 +00:00
|
|
|
int ret, psize, total_read = 0, i;
|
2012-09-03 00:51:00 +00:00
|
|
|
AVPacket idx_pkt;
|
|
|
|
|
avformat/vobsub: fix several issues.
Here is an extract of fate-samples/sub/vobsub.idx, with an additional
text at the end of each line to better identify each bitmap:
timestamp: 00:04:55:445, filepos: 00001b000 Ace!
timestamp: 00:05:00:049, filepos: 00001b800 Wake up, honey!
timestamp: 00:05:02:018, filepos: 00001c800 I gotta go to work.
timestamp: 00:05:02:035, filepos: 00001d000 <???>
timestamp: 00:05:04:203, filepos: 00001d800 Look after Clayton, okay?
timestamp: 00:05:05:947, filepos: 00001e800 I'll be back tonight.
timestamp: 00:05:07:957, filepos: 00001f800 Bye! Love you.
timestamp: 00:05:21:295, filepos: 000020800 Hey, Ace! What's up?
timestamp: 00:05:23:356, filepos: 000021800 Hey, how's it going?
timestamp: 00:05:24:640, filepos: 000022800 Remember what today is? The 3rd!
timestamp: 00:05:27:193, filepos: 000023800 Look over there!
timestamp: 00:05:28:369, filepos: 000024800 Where are they going?
timestamp: 00:05:28:361, filepos: 000025000 <???>
timestamp: 00:05:29:946, filepos: 000025800 Let's go see.
timestamp: 00:05:31:230, filepos: 000026000 I can't, man. I got Clayton.
Note the two "<???>": they are basically split subtitles (with the
previous one), which the dvdsub decoder is now supposed to reconstruct
with a previous commit. But also note that while the first chunk has
increasing timestamps,
timestamp: 00:05:02:018, filepos: 00001c800
timestamp: 00:05:02:035, filepos: 00001d000
...it's not the case of the second one (and this is not an exception in the
original file):
timestamp: 00:05:28:369, filepos: 000024800
timestamp: 00:05:28:361, filepos: 000025000
For the dvdsub decoder, they need to be "filepos'ed" ordered, but the
FFDemuxSubtitlesQueue is timestamps ordered, which is the reason of the
introduction of a sub sort method in the context, to allow giving
priority to the position, and then the timestamps. With that change, the
dvdsub decoder get fed with ordered packets.
Now the packet size estimation was also broken: the filepos differences
in the vobsub index defines the full data read between two subtitles
chunks, and it is necessary to take into account what is read by the
mpegps_read_pes_header() function since the length returned by that
function doesn't count the size of the data it reads. This is fixed with
the introduction of total_read, and {old,new}_pos. By doing this change,
we can drop the unreliable len16 heuristic and simplify the whole loop.
Note that mpegps_read_pes_header() often read more than one PES packet
(typically in one call it can read 0x1ba and 0x1be chunk along with the
relevant 0x1bd packet), which triggers the "total_read + pkt_size >
psize" check. This is an expected behaviour, which could be avoided by
having a more chunked version of mpegps_read_pes_header().
The latest change is the extraction of each stream into its own
subtitles queue. If we don't do this, the maximum size for a subtitle
chunk is broken, and the previous changes can not work. Having each
stream in a different queue requires some little adjustments in the
seek code of the demuxer.
This commit is only meaningful as a whole change and can not be easily
split. The FATE test changes because it uses the vobsub demuxer.
2013-09-29 20:05:14 +00:00
|
|
|
int64_t min_ts = INT64_MAX;
|
|
|
|
int sid = 0;
|
|
|
|
for (i = 0; i < s->nb_streams; i++) {
|
|
|
|
FFDemuxSubtitlesQueue *tmpq = &vobsub->q[i];
|
2014-05-24 09:03:23 +00:00
|
|
|
int64_t ts;
|
|
|
|
av_assert0(tmpq->nb_subs);
|
|
|
|
ts = tmpq->subs[tmpq->current_sub_idx].pts;
|
avformat/vobsub: fix several issues.
Here is an extract of fate-samples/sub/vobsub.idx, with an additional
text at the end of each line to better identify each bitmap:
timestamp: 00:04:55:445, filepos: 00001b000 Ace!
timestamp: 00:05:00:049, filepos: 00001b800 Wake up, honey!
timestamp: 00:05:02:018, filepos: 00001c800 I gotta go to work.
timestamp: 00:05:02:035, filepos: 00001d000 <???>
timestamp: 00:05:04:203, filepos: 00001d800 Look after Clayton, okay?
timestamp: 00:05:05:947, filepos: 00001e800 I'll be back tonight.
timestamp: 00:05:07:957, filepos: 00001f800 Bye! Love you.
timestamp: 00:05:21:295, filepos: 000020800 Hey, Ace! What's up?
timestamp: 00:05:23:356, filepos: 000021800 Hey, how's it going?
timestamp: 00:05:24:640, filepos: 000022800 Remember what today is? The 3rd!
timestamp: 00:05:27:193, filepos: 000023800 Look over there!
timestamp: 00:05:28:369, filepos: 000024800 Where are they going?
timestamp: 00:05:28:361, filepos: 000025000 <???>
timestamp: 00:05:29:946, filepos: 000025800 Let's go see.
timestamp: 00:05:31:230, filepos: 000026000 I can't, man. I got Clayton.
Note the two "<???>": they are basically split subtitles (with the
previous one), which the dvdsub decoder is now supposed to reconstruct
with a previous commit. But also note that while the first chunk has
increasing timestamps,
timestamp: 00:05:02:018, filepos: 00001c800
timestamp: 00:05:02:035, filepos: 00001d000
...it's not the case of the second one (and this is not an exception in the
original file):
timestamp: 00:05:28:369, filepos: 000024800
timestamp: 00:05:28:361, filepos: 000025000
For the dvdsub decoder, they need to be "filepos'ed" ordered, but the
FFDemuxSubtitlesQueue is timestamps ordered, which is the reason of the
introduction of a sub sort method in the context, to allow giving
priority to the position, and then the timestamps. With that change, the
dvdsub decoder get fed with ordered packets.
Now the packet size estimation was also broken: the filepos differences
in the vobsub index defines the full data read between two subtitles
chunks, and it is necessary to take into account what is read by the
mpegps_read_pes_header() function since the length returned by that
function doesn't count the size of the data it reads. This is fixed with
the introduction of total_read, and {old,new}_pos. By doing this change,
we can drop the unreliable len16 heuristic and simplify the whole loop.
Note that mpegps_read_pes_header() often read more than one PES packet
(typically in one call it can read 0x1ba and 0x1be chunk along with the
relevant 0x1bd packet), which triggers the "total_read + pkt_size >
psize" check. This is an expected behaviour, which could be avoided by
having a more chunked version of mpegps_read_pes_header().
The latest change is the extraction of each stream into its own
subtitles queue. If we don't do this, the maximum size for a subtitle
chunk is broken, and the previous changes can not work. Having each
stream in a different queue requires some little adjustments in the
seek code of the demuxer.
This commit is only meaningful as a whole change and can not be easily
split. The FATE test changes because it uses the vobsub demuxer.
2013-09-29 20:05:14 +00:00
|
|
|
if (ts < min_ts) {
|
|
|
|
min_ts = ts;
|
|
|
|
sid = i;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
q = &vobsub->q[sid];
|
2012-09-03 00:51:00 +00:00
|
|
|
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;
|
avformat/vobsub: fix several issues.
Here is an extract of fate-samples/sub/vobsub.idx, with an additional
text at the end of each line to better identify each bitmap:
timestamp: 00:04:55:445, filepos: 00001b000 Ace!
timestamp: 00:05:00:049, filepos: 00001b800 Wake up, honey!
timestamp: 00:05:02:018, filepos: 00001c800 I gotta go to work.
timestamp: 00:05:02:035, filepos: 00001d000 <???>
timestamp: 00:05:04:203, filepos: 00001d800 Look after Clayton, okay?
timestamp: 00:05:05:947, filepos: 00001e800 I'll be back tonight.
timestamp: 00:05:07:957, filepos: 00001f800 Bye! Love you.
timestamp: 00:05:21:295, filepos: 000020800 Hey, Ace! What's up?
timestamp: 00:05:23:356, filepos: 000021800 Hey, how's it going?
timestamp: 00:05:24:640, filepos: 000022800 Remember what today is? The 3rd!
timestamp: 00:05:27:193, filepos: 000023800 Look over there!
timestamp: 00:05:28:369, filepos: 000024800 Where are they going?
timestamp: 00:05:28:361, filepos: 000025000 <???>
timestamp: 00:05:29:946, filepos: 000025800 Let's go see.
timestamp: 00:05:31:230, filepos: 000026000 I can't, man. I got Clayton.
Note the two "<???>": they are basically split subtitles (with the
previous one), which the dvdsub decoder is now supposed to reconstruct
with a previous commit. But also note that while the first chunk has
increasing timestamps,
timestamp: 00:05:02:018, filepos: 00001c800
timestamp: 00:05:02:035, filepos: 00001d000
...it's not the case of the second one (and this is not an exception in the
original file):
timestamp: 00:05:28:369, filepos: 000024800
timestamp: 00:05:28:361, filepos: 000025000
For the dvdsub decoder, they need to be "filepos'ed" ordered, but the
FFDemuxSubtitlesQueue is timestamps ordered, which is the reason of the
introduction of a sub sort method in the context, to allow giving
priority to the position, and then the timestamps. With that change, the
dvdsub decoder get fed with ordered packets.
Now the packet size estimation was also broken: the filepos differences
in the vobsub index defines the full data read between two subtitles
chunks, and it is necessary to take into account what is read by the
mpegps_read_pes_header() function since the length returned by that
function doesn't count the size of the data it reads. This is fixed with
the introduction of total_read, and {old,new}_pos. By doing this change,
we can drop the unreliable len16 heuristic and simplify the whole loop.
Note that mpegps_read_pes_header() often read more than one PES packet
(typically in one call it can read 0x1ba and 0x1be chunk along with the
relevant 0x1bd packet), which triggers the "total_read + pkt_size >
psize" check. This is an expected behaviour, which could be avoided by
having a more chunked version of mpegps_read_pes_header().
The latest change is the extraction of each stream into its own
subtitles queue. If we don't do this, the maximum size for a subtitle
chunk is broken, and the previous changes can not work. Having each
stream in a different queue requires some little adjustments in the
seek code of the demuxer.
This commit is only meaningful as a whole change and can not be easily
split. The FATE test changes because it uses the vobsub demuxer.
2013-09-29 20:05:14 +00:00
|
|
|
int64_t old_pos = avio_tell(pb), new_pos;
|
|
|
|
int pkt_size;
|
2012-09-03 00:51:00 +00:00
|
|
|
|
|
|
|
ret = mpegps_read_pes_header(vobsub->sub_ctx, NULL, &startcode, &pts, &dts);
|
2013-10-04 09:25:08 +00:00
|
|
|
if (ret < 0) {
|
|
|
|
if (pkt->size) // raise packet even if incomplete
|
|
|
|
break;
|
2014-05-01 14:16:38 +00:00
|
|
|
goto fail;
|
2013-10-04 09:25:08 +00:00
|
|
|
}
|
2012-09-03 00:51:00 +00:00
|
|
|
to_read = ret & 0xffff;
|
avformat/vobsub: fix several issues.
Here is an extract of fate-samples/sub/vobsub.idx, with an additional
text at the end of each line to better identify each bitmap:
timestamp: 00:04:55:445, filepos: 00001b000 Ace!
timestamp: 00:05:00:049, filepos: 00001b800 Wake up, honey!
timestamp: 00:05:02:018, filepos: 00001c800 I gotta go to work.
timestamp: 00:05:02:035, filepos: 00001d000 <???>
timestamp: 00:05:04:203, filepos: 00001d800 Look after Clayton, okay?
timestamp: 00:05:05:947, filepos: 00001e800 I'll be back tonight.
timestamp: 00:05:07:957, filepos: 00001f800 Bye! Love you.
timestamp: 00:05:21:295, filepos: 000020800 Hey, Ace! What's up?
timestamp: 00:05:23:356, filepos: 000021800 Hey, how's it going?
timestamp: 00:05:24:640, filepos: 000022800 Remember what today is? The 3rd!
timestamp: 00:05:27:193, filepos: 000023800 Look over there!
timestamp: 00:05:28:369, filepos: 000024800 Where are they going?
timestamp: 00:05:28:361, filepos: 000025000 <???>
timestamp: 00:05:29:946, filepos: 000025800 Let's go see.
timestamp: 00:05:31:230, filepos: 000026000 I can't, man. I got Clayton.
Note the two "<???>": they are basically split subtitles (with the
previous one), which the dvdsub decoder is now supposed to reconstruct
with a previous commit. But also note that while the first chunk has
increasing timestamps,
timestamp: 00:05:02:018, filepos: 00001c800
timestamp: 00:05:02:035, filepos: 00001d000
...it's not the case of the second one (and this is not an exception in the
original file):
timestamp: 00:05:28:369, filepos: 000024800
timestamp: 00:05:28:361, filepos: 000025000
For the dvdsub decoder, they need to be "filepos'ed" ordered, but the
FFDemuxSubtitlesQueue is timestamps ordered, which is the reason of the
introduction of a sub sort method in the context, to allow giving
priority to the position, and then the timestamps. With that change, the
dvdsub decoder get fed with ordered packets.
Now the packet size estimation was also broken: the filepos differences
in the vobsub index defines the full data read between two subtitles
chunks, and it is necessary to take into account what is read by the
mpegps_read_pes_header() function since the length returned by that
function doesn't count the size of the data it reads. This is fixed with
the introduction of total_read, and {old,new}_pos. By doing this change,
we can drop the unreliable len16 heuristic and simplify the whole loop.
Note that mpegps_read_pes_header() often read more than one PES packet
(typically in one call it can read 0x1ba and 0x1be chunk along with the
relevant 0x1bd packet), which triggers the "total_read + pkt_size >
psize" check. This is an expected behaviour, which could be avoided by
having a more chunked version of mpegps_read_pes_header().
The latest change is the extraction of each stream into its own
subtitles queue. If we don't do this, the maximum size for a subtitle
chunk is broken, and the previous changes can not work. Having each
stream in a different queue requires some little adjustments in the
seek code of the demuxer.
This commit is only meaningful as a whole change and can not be easily
split. The FATE test changes because it uses the vobsub demuxer.
2013-09-29 20:05:14 +00:00
|
|
|
new_pos = avio_tell(pb);
|
|
|
|
pkt_size = ret + (new_pos - old_pos);
|
2012-09-03 00:51:00 +00:00
|
|
|
|
|
|
|
/* this prevents reads above the current packet */
|
avformat/vobsub: fix several issues.
Here is an extract of fate-samples/sub/vobsub.idx, with an additional
text at the end of each line to better identify each bitmap:
timestamp: 00:04:55:445, filepos: 00001b000 Ace!
timestamp: 00:05:00:049, filepos: 00001b800 Wake up, honey!
timestamp: 00:05:02:018, filepos: 00001c800 I gotta go to work.
timestamp: 00:05:02:035, filepos: 00001d000 <???>
timestamp: 00:05:04:203, filepos: 00001d800 Look after Clayton, okay?
timestamp: 00:05:05:947, filepos: 00001e800 I'll be back tonight.
timestamp: 00:05:07:957, filepos: 00001f800 Bye! Love you.
timestamp: 00:05:21:295, filepos: 000020800 Hey, Ace! What's up?
timestamp: 00:05:23:356, filepos: 000021800 Hey, how's it going?
timestamp: 00:05:24:640, filepos: 000022800 Remember what today is? The 3rd!
timestamp: 00:05:27:193, filepos: 000023800 Look over there!
timestamp: 00:05:28:369, filepos: 000024800 Where are they going?
timestamp: 00:05:28:361, filepos: 000025000 <???>
timestamp: 00:05:29:946, filepos: 000025800 Let's go see.
timestamp: 00:05:31:230, filepos: 000026000 I can't, man. I got Clayton.
Note the two "<???>": they are basically split subtitles (with the
previous one), which the dvdsub decoder is now supposed to reconstruct
with a previous commit. But also note that while the first chunk has
increasing timestamps,
timestamp: 00:05:02:018, filepos: 00001c800
timestamp: 00:05:02:035, filepos: 00001d000
...it's not the case of the second one (and this is not an exception in the
original file):
timestamp: 00:05:28:369, filepos: 000024800
timestamp: 00:05:28:361, filepos: 000025000
For the dvdsub decoder, they need to be "filepos'ed" ordered, but the
FFDemuxSubtitlesQueue is timestamps ordered, which is the reason of the
introduction of a sub sort method in the context, to allow giving
priority to the position, and then the timestamps. With that change, the
dvdsub decoder get fed with ordered packets.
Now the packet size estimation was also broken: the filepos differences
in the vobsub index defines the full data read between two subtitles
chunks, and it is necessary to take into account what is read by the
mpegps_read_pes_header() function since the length returned by that
function doesn't count the size of the data it reads. This is fixed with
the introduction of total_read, and {old,new}_pos. By doing this change,
we can drop the unreliable len16 heuristic and simplify the whole loop.
Note that mpegps_read_pes_header() often read more than one PES packet
(typically in one call it can read 0x1ba and 0x1be chunk along with the
relevant 0x1bd packet), which triggers the "total_read + pkt_size >
psize" check. This is an expected behaviour, which could be avoided by
having a more chunked version of mpegps_read_pes_header().
The latest change is the extraction of each stream into its own
subtitles queue. If we don't do this, the maximum size for a subtitle
chunk is broken, and the previous changes can not work. Having each
stream in a different queue requires some little adjustments in the
seek code of the demuxer.
This commit is only meaningful as a whole change and can not be easily
split. The FATE test changes because it uses the vobsub demuxer.
2013-09-29 20:05:14 +00:00
|
|
|
if (total_read + pkt_size > psize)
|
2012-09-03 00:51:00 +00:00
|
|
|
break;
|
avformat/vobsub: fix several issues.
Here is an extract of fate-samples/sub/vobsub.idx, with an additional
text at the end of each line to better identify each bitmap:
timestamp: 00:04:55:445, filepos: 00001b000 Ace!
timestamp: 00:05:00:049, filepos: 00001b800 Wake up, honey!
timestamp: 00:05:02:018, filepos: 00001c800 I gotta go to work.
timestamp: 00:05:02:035, filepos: 00001d000 <???>
timestamp: 00:05:04:203, filepos: 00001d800 Look after Clayton, okay?
timestamp: 00:05:05:947, filepos: 00001e800 I'll be back tonight.
timestamp: 00:05:07:957, filepos: 00001f800 Bye! Love you.
timestamp: 00:05:21:295, filepos: 000020800 Hey, Ace! What's up?
timestamp: 00:05:23:356, filepos: 000021800 Hey, how's it going?
timestamp: 00:05:24:640, filepos: 000022800 Remember what today is? The 3rd!
timestamp: 00:05:27:193, filepos: 000023800 Look over there!
timestamp: 00:05:28:369, filepos: 000024800 Where are they going?
timestamp: 00:05:28:361, filepos: 000025000 <???>
timestamp: 00:05:29:946, filepos: 000025800 Let's go see.
timestamp: 00:05:31:230, filepos: 000026000 I can't, man. I got Clayton.
Note the two "<???>": they are basically split subtitles (with the
previous one), which the dvdsub decoder is now supposed to reconstruct
with a previous commit. But also note that while the first chunk has
increasing timestamps,
timestamp: 00:05:02:018, filepos: 00001c800
timestamp: 00:05:02:035, filepos: 00001d000
...it's not the case of the second one (and this is not an exception in the
original file):
timestamp: 00:05:28:369, filepos: 000024800
timestamp: 00:05:28:361, filepos: 000025000
For the dvdsub decoder, they need to be "filepos'ed" ordered, but the
FFDemuxSubtitlesQueue is timestamps ordered, which is the reason of the
introduction of a sub sort method in the context, to allow giving
priority to the position, and then the timestamps. With that change, the
dvdsub decoder get fed with ordered packets.
Now the packet size estimation was also broken: the filepos differences
in the vobsub index defines the full data read between two subtitles
chunks, and it is necessary to take into account what is read by the
mpegps_read_pes_header() function since the length returned by that
function doesn't count the size of the data it reads. This is fixed with
the introduction of total_read, and {old,new}_pos. By doing this change,
we can drop the unreliable len16 heuristic and simplify the whole loop.
Note that mpegps_read_pes_header() often read more than one PES packet
(typically in one call it can read 0x1ba and 0x1be chunk along with the
relevant 0x1bd packet), which triggers the "total_read + pkt_size >
psize" check. This is an expected behaviour, which could be avoided by
having a more chunked version of mpegps_read_pes_header().
The latest change is the extraction of each stream into its own
subtitles queue. If we don't do this, the maximum size for a subtitle
chunk is broken, and the previous changes can not work. Having each
stream in a different queue requires some little adjustments in the
seek code of the demuxer.
This commit is only meaningful as a whole change and can not be easily
split. The FATE test changes because it uses the vobsub demuxer.
2013-09-29 20:05:14 +00:00
|
|
|
total_read += pkt_size;
|
2012-09-03 00:51:00 +00:00
|
|
|
|
|
|
|
/* 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)
|
2014-05-01 14:16:38 +00:00
|
|
|
goto fail;
|
2012-09-03 00:51:00 +00:00
|
|
|
|
|
|
|
n = avio_read(pb, pkt->data + (pkt->size - to_read), to_read);
|
|
|
|
if (n < to_read)
|
|
|
|
pkt->size -= to_read - n;
|
avformat/vobsub: fix several issues.
Here is an extract of fate-samples/sub/vobsub.idx, with an additional
text at the end of each line to better identify each bitmap:
timestamp: 00:04:55:445, filepos: 00001b000 Ace!
timestamp: 00:05:00:049, filepos: 00001b800 Wake up, honey!
timestamp: 00:05:02:018, filepos: 00001c800 I gotta go to work.
timestamp: 00:05:02:035, filepos: 00001d000 <???>
timestamp: 00:05:04:203, filepos: 00001d800 Look after Clayton, okay?
timestamp: 00:05:05:947, filepos: 00001e800 I'll be back tonight.
timestamp: 00:05:07:957, filepos: 00001f800 Bye! Love you.
timestamp: 00:05:21:295, filepos: 000020800 Hey, Ace! What's up?
timestamp: 00:05:23:356, filepos: 000021800 Hey, how's it going?
timestamp: 00:05:24:640, filepos: 000022800 Remember what today is? The 3rd!
timestamp: 00:05:27:193, filepos: 000023800 Look over there!
timestamp: 00:05:28:369, filepos: 000024800 Where are they going?
timestamp: 00:05:28:361, filepos: 000025000 <???>
timestamp: 00:05:29:946, filepos: 000025800 Let's go see.
timestamp: 00:05:31:230, filepos: 000026000 I can't, man. I got Clayton.
Note the two "<???>": they are basically split subtitles (with the
previous one), which the dvdsub decoder is now supposed to reconstruct
with a previous commit. But also note that while the first chunk has
increasing timestamps,
timestamp: 00:05:02:018, filepos: 00001c800
timestamp: 00:05:02:035, filepos: 00001d000
...it's not the case of the second one (and this is not an exception in the
original file):
timestamp: 00:05:28:369, filepos: 000024800
timestamp: 00:05:28:361, filepos: 000025000
For the dvdsub decoder, they need to be "filepos'ed" ordered, but the
FFDemuxSubtitlesQueue is timestamps ordered, which is the reason of the
introduction of a sub sort method in the context, to allow giving
priority to the position, and then the timestamps. With that change, the
dvdsub decoder get fed with ordered packets.
Now the packet size estimation was also broken: the filepos differences
in the vobsub index defines the full data read between two subtitles
chunks, and it is necessary to take into account what is read by the
mpegps_read_pes_header() function since the length returned by that
function doesn't count the size of the data it reads. This is fixed with
the introduction of total_read, and {old,new}_pos. By doing this change,
we can drop the unreliable len16 heuristic and simplify the whole loop.
Note that mpegps_read_pes_header() often read more than one PES packet
(typically in one call it can read 0x1ba and 0x1be chunk along with the
relevant 0x1bd packet), which triggers the "total_read + pkt_size >
psize" check. This is an expected behaviour, which could be avoided by
having a more chunked version of mpegps_read_pes_header().
The latest change is the extraction of each stream into its own
subtitles queue. If we don't do this, the maximum size for a subtitle
chunk is broken, and the previous changes can not work. Having each
stream in a different queue requires some little adjustments in the
seek code of the demuxer.
This commit is only meaningful as a whole change and can not be easily
split. The FATE test changes because it uses the vobsub demuxer.
2013-09-29 20:05:14 +00:00
|
|
|
} while (total_read < psize);
|
2012-09-03 00:51:00 +00:00
|
|
|
|
|
|
|
pkt->pts = pkt->dts = idx_pkt.pts;
|
|
|
|
pkt->pos = idx_pkt.pos;
|
|
|
|
pkt->stream_index = idx_pkt.stream_index;
|
|
|
|
|
2013-03-20 10:12:59 +00:00
|
|
|
av_free_packet(&idx_pkt);
|
2012-09-03 00:51:00 +00:00
|
|
|
return 0;
|
2013-03-20 10:12:59 +00:00
|
|
|
|
|
|
|
fail:
|
avformat/vobsub: fix several issues.
Here is an extract of fate-samples/sub/vobsub.idx, with an additional
text at the end of each line to better identify each bitmap:
timestamp: 00:04:55:445, filepos: 00001b000 Ace!
timestamp: 00:05:00:049, filepos: 00001b800 Wake up, honey!
timestamp: 00:05:02:018, filepos: 00001c800 I gotta go to work.
timestamp: 00:05:02:035, filepos: 00001d000 <???>
timestamp: 00:05:04:203, filepos: 00001d800 Look after Clayton, okay?
timestamp: 00:05:05:947, filepos: 00001e800 I'll be back tonight.
timestamp: 00:05:07:957, filepos: 00001f800 Bye! Love you.
timestamp: 00:05:21:295, filepos: 000020800 Hey, Ace! What's up?
timestamp: 00:05:23:356, filepos: 000021800 Hey, how's it going?
timestamp: 00:05:24:640, filepos: 000022800 Remember what today is? The 3rd!
timestamp: 00:05:27:193, filepos: 000023800 Look over there!
timestamp: 00:05:28:369, filepos: 000024800 Where are they going?
timestamp: 00:05:28:361, filepos: 000025000 <???>
timestamp: 00:05:29:946, filepos: 000025800 Let's go see.
timestamp: 00:05:31:230, filepos: 000026000 I can't, man. I got Clayton.
Note the two "<???>": they are basically split subtitles (with the
previous one), which the dvdsub decoder is now supposed to reconstruct
with a previous commit. But also note that while the first chunk has
increasing timestamps,
timestamp: 00:05:02:018, filepos: 00001c800
timestamp: 00:05:02:035, filepos: 00001d000
...it's not the case of the second one (and this is not an exception in the
original file):
timestamp: 00:05:28:369, filepos: 000024800
timestamp: 00:05:28:361, filepos: 000025000
For the dvdsub decoder, they need to be "filepos'ed" ordered, but the
FFDemuxSubtitlesQueue is timestamps ordered, which is the reason of the
introduction of a sub sort method in the context, to allow giving
priority to the position, and then the timestamps. With that change, the
dvdsub decoder get fed with ordered packets.
Now the packet size estimation was also broken: the filepos differences
in the vobsub index defines the full data read between two subtitles
chunks, and it is necessary to take into account what is read by the
mpegps_read_pes_header() function since the length returned by that
function doesn't count the size of the data it reads. This is fixed with
the introduction of total_read, and {old,new}_pos. By doing this change,
we can drop the unreliable len16 heuristic and simplify the whole loop.
Note that mpegps_read_pes_header() often read more than one PES packet
(typically in one call it can read 0x1ba and 0x1be chunk along with the
relevant 0x1bd packet), which triggers the "total_read + pkt_size >
psize" check. This is an expected behaviour, which could be avoided by
having a more chunked version of mpegps_read_pes_header().
The latest change is the extraction of each stream into its own
subtitles queue. If we don't do this, the maximum size for a subtitle
chunk is broken, and the previous changes can not work. Having each
stream in a different queue requires some little adjustments in the
seek code of the demuxer.
This commit is only meaningful as a whole change and can not be easily
split. The FATE test changes because it uses the vobsub demuxer.
2013-09-29 20:05:14 +00:00
|
|
|
av_free_packet(pkt);
|
2013-03-20 10:12:59 +00:00
|
|
|
av_free_packet(&idx_pkt);
|
|
|
|
return ret;
|
2012-09-03 00:51:00 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
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;
|
2013-09-08 07:43:53 +00:00
|
|
|
|
|
|
|
/* 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) {
|
avformat/vobsub: fix several issues.
Here is an extract of fate-samples/sub/vobsub.idx, with an additional
text at the end of each line to better identify each bitmap:
timestamp: 00:04:55:445, filepos: 00001b000 Ace!
timestamp: 00:05:00:049, filepos: 00001b800 Wake up, honey!
timestamp: 00:05:02:018, filepos: 00001c800 I gotta go to work.
timestamp: 00:05:02:035, filepos: 00001d000 <???>
timestamp: 00:05:04:203, filepos: 00001d800 Look after Clayton, okay?
timestamp: 00:05:05:947, filepos: 00001e800 I'll be back tonight.
timestamp: 00:05:07:957, filepos: 00001f800 Bye! Love you.
timestamp: 00:05:21:295, filepos: 000020800 Hey, Ace! What's up?
timestamp: 00:05:23:356, filepos: 000021800 Hey, how's it going?
timestamp: 00:05:24:640, filepos: 000022800 Remember what today is? The 3rd!
timestamp: 00:05:27:193, filepos: 000023800 Look over there!
timestamp: 00:05:28:369, filepos: 000024800 Where are they going?
timestamp: 00:05:28:361, filepos: 000025000 <???>
timestamp: 00:05:29:946, filepos: 000025800 Let's go see.
timestamp: 00:05:31:230, filepos: 000026000 I can't, man. I got Clayton.
Note the two "<???>": they are basically split subtitles (with the
previous one), which the dvdsub decoder is now supposed to reconstruct
with a previous commit. But also note that while the first chunk has
increasing timestamps,
timestamp: 00:05:02:018, filepos: 00001c800
timestamp: 00:05:02:035, filepos: 00001d000
...it's not the case of the second one (and this is not an exception in the
original file):
timestamp: 00:05:28:369, filepos: 000024800
timestamp: 00:05:28:361, filepos: 000025000
For the dvdsub decoder, they need to be "filepos'ed" ordered, but the
FFDemuxSubtitlesQueue is timestamps ordered, which is the reason of the
introduction of a sub sort method in the context, to allow giving
priority to the position, and then the timestamps. With that change, the
dvdsub decoder get fed with ordered packets.
Now the packet size estimation was also broken: the filepos differences
in the vobsub index defines the full data read between two subtitles
chunks, and it is necessary to take into account what is read by the
mpegps_read_pes_header() function since the length returned by that
function doesn't count the size of the data it reads. This is fixed with
the introduction of total_read, and {old,new}_pos. By doing this change,
we can drop the unreliable len16 heuristic and simplify the whole loop.
Note that mpegps_read_pes_header() often read more than one PES packet
(typically in one call it can read 0x1ba and 0x1be chunk along with the
relevant 0x1bd packet), which triggers the "total_read + pkt_size >
psize" check. This is an expected behaviour, which could be avoided by
having a more chunked version of mpegps_read_pes_header().
The latest change is the extraction of each stream into its own
subtitles queue. If we don't do this, the maximum size for a subtitle
chunk is broken, and the previous changes can not work. Having each
stream in a different queue requires some little adjustments in the
seek code of the demuxer.
This commit is only meaningful as a whole change and can not be easily
split. The FATE test changes because it uses the vobsub demuxer.
2013-09-29 20:05:14 +00:00
|
|
|
int i, ret = 0;
|
2013-09-08 07:43:53 +00:00
|
|
|
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);
|
avformat/vobsub: fix several issues.
Here is an extract of fate-samples/sub/vobsub.idx, with an additional
text at the end of each line to better identify each bitmap:
timestamp: 00:04:55:445, filepos: 00001b000 Ace!
timestamp: 00:05:00:049, filepos: 00001b800 Wake up, honey!
timestamp: 00:05:02:018, filepos: 00001c800 I gotta go to work.
timestamp: 00:05:02:035, filepos: 00001d000 <???>
timestamp: 00:05:04:203, filepos: 00001d800 Look after Clayton, okay?
timestamp: 00:05:05:947, filepos: 00001e800 I'll be back tonight.
timestamp: 00:05:07:957, filepos: 00001f800 Bye! Love you.
timestamp: 00:05:21:295, filepos: 000020800 Hey, Ace! What's up?
timestamp: 00:05:23:356, filepos: 000021800 Hey, how's it going?
timestamp: 00:05:24:640, filepos: 000022800 Remember what today is? The 3rd!
timestamp: 00:05:27:193, filepos: 000023800 Look over there!
timestamp: 00:05:28:369, filepos: 000024800 Where are they going?
timestamp: 00:05:28:361, filepos: 000025000 <???>
timestamp: 00:05:29:946, filepos: 000025800 Let's go see.
timestamp: 00:05:31:230, filepos: 000026000 I can't, man. I got Clayton.
Note the two "<???>": they are basically split subtitles (with the
previous one), which the dvdsub decoder is now supposed to reconstruct
with a previous commit. But also note that while the first chunk has
increasing timestamps,
timestamp: 00:05:02:018, filepos: 00001c800
timestamp: 00:05:02:035, filepos: 00001d000
...it's not the case of the second one (and this is not an exception in the
original file):
timestamp: 00:05:28:369, filepos: 000024800
timestamp: 00:05:28:361, filepos: 000025000
For the dvdsub decoder, they need to be "filepos'ed" ordered, but the
FFDemuxSubtitlesQueue is timestamps ordered, which is the reason of the
introduction of a sub sort method in the context, to allow giving
priority to the position, and then the timestamps. With that change, the
dvdsub decoder get fed with ordered packets.
Now the packet size estimation was also broken: the filepos differences
in the vobsub index defines the full data read between two subtitles
chunks, and it is necessary to take into account what is read by the
mpegps_read_pes_header() function since the length returned by that
function doesn't count the size of the data it reads. This is fixed with
the introduction of total_read, and {old,new}_pos. By doing this change,
we can drop the unreliable len16 heuristic and simplify the whole loop.
Note that mpegps_read_pes_header() often read more than one PES packet
(typically in one call it can read 0x1ba and 0x1be chunk along with the
relevant 0x1bd packet), which triggers the "total_read + pkt_size >
psize" check. This is an expected behaviour, which could be avoided by
having a more chunked version of mpegps_read_pes_header().
The latest change is the extraction of each stream into its own
subtitles queue. If we don't do this, the maximum size for a subtitle
chunk is broken, and the previous changes can not work. Having each
stream in a different queue requires some little adjustments in the
seek code of the demuxer.
This commit is only meaningful as a whole change and can not be easily
split. The FATE test changes because it uses the vobsub demuxer.
2013-09-29 20:05:14 +00:00
|
|
|
for (i = 0; i < s->nb_streams; i++) {
|
|
|
|
int r = ff_subtitles_queue_seek(&vobsub->q[i], s, stream_index,
|
|
|
|
min_ts, ts, max_ts, flags);
|
|
|
|
if (r < 0)
|
|
|
|
ret = r;
|
|
|
|
}
|
|
|
|
return ret;
|
2013-09-08 07:43:53 +00:00
|
|
|
}
|
|
|
|
|
2013-10-20 19:23:43 +00:00
|
|
|
if (stream_index == -1) // only 1 stream
|
|
|
|
stream_index = 0;
|
avformat/vobsub: fix several issues.
Here is an extract of fate-samples/sub/vobsub.idx, with an additional
text at the end of each line to better identify each bitmap:
timestamp: 00:04:55:445, filepos: 00001b000 Ace!
timestamp: 00:05:00:049, filepos: 00001b800 Wake up, honey!
timestamp: 00:05:02:018, filepos: 00001c800 I gotta go to work.
timestamp: 00:05:02:035, filepos: 00001d000 <???>
timestamp: 00:05:04:203, filepos: 00001d800 Look after Clayton, okay?
timestamp: 00:05:05:947, filepos: 00001e800 I'll be back tonight.
timestamp: 00:05:07:957, filepos: 00001f800 Bye! Love you.
timestamp: 00:05:21:295, filepos: 000020800 Hey, Ace! What's up?
timestamp: 00:05:23:356, filepos: 000021800 Hey, how's it going?
timestamp: 00:05:24:640, filepos: 000022800 Remember what today is? The 3rd!
timestamp: 00:05:27:193, filepos: 000023800 Look over there!
timestamp: 00:05:28:369, filepos: 000024800 Where are they going?
timestamp: 00:05:28:361, filepos: 000025000 <???>
timestamp: 00:05:29:946, filepos: 000025800 Let's go see.
timestamp: 00:05:31:230, filepos: 000026000 I can't, man. I got Clayton.
Note the two "<???>": they are basically split subtitles (with the
previous one), which the dvdsub decoder is now supposed to reconstruct
with a previous commit. But also note that while the first chunk has
increasing timestamps,
timestamp: 00:05:02:018, filepos: 00001c800
timestamp: 00:05:02:035, filepos: 00001d000
...it's not the case of the second one (and this is not an exception in the
original file):
timestamp: 00:05:28:369, filepos: 000024800
timestamp: 00:05:28:361, filepos: 000025000
For the dvdsub decoder, they need to be "filepos'ed" ordered, but the
FFDemuxSubtitlesQueue is timestamps ordered, which is the reason of the
introduction of a sub sort method in the context, to allow giving
priority to the position, and then the timestamps. With that change, the
dvdsub decoder get fed with ordered packets.
Now the packet size estimation was also broken: the filepos differences
in the vobsub index defines the full data read between two subtitles
chunks, and it is necessary to take into account what is read by the
mpegps_read_pes_header() function since the length returned by that
function doesn't count the size of the data it reads. This is fixed with
the introduction of total_read, and {old,new}_pos. By doing this change,
we can drop the unreliable len16 heuristic and simplify the whole loop.
Note that mpegps_read_pes_header() often read more than one PES packet
(typically in one call it can read 0x1ba and 0x1be chunk along with the
relevant 0x1bd packet), which triggers the "total_read + pkt_size >
psize" check. This is an expected behaviour, which could be avoided by
having a more chunked version of mpegps_read_pes_header().
The latest change is the extraction of each stream into its own
subtitles queue. If we don't do this, the maximum size for a subtitle
chunk is broken, and the previous changes can not work. Having each
stream in a different queue requires some little adjustments in the
seek code of the demuxer.
This commit is only meaningful as a whole change and can not be easily
split. The FATE test changes because it uses the vobsub demuxer.
2013-09-29 20:05:14 +00:00
|
|
|
return ff_subtitles_queue_seek(&vobsub->q[stream_index], s, stream_index,
|
2012-09-03 00:51:00 +00:00
|
|
|
min_ts, ts, max_ts, flags);
|
|
|
|
}
|
|
|
|
|
|
|
|
static int vobsub_read_close(AVFormatContext *s)
|
|
|
|
{
|
avformat/vobsub: fix several issues.
Here is an extract of fate-samples/sub/vobsub.idx, with an additional
text at the end of each line to better identify each bitmap:
timestamp: 00:04:55:445, filepos: 00001b000 Ace!
timestamp: 00:05:00:049, filepos: 00001b800 Wake up, honey!
timestamp: 00:05:02:018, filepos: 00001c800 I gotta go to work.
timestamp: 00:05:02:035, filepos: 00001d000 <???>
timestamp: 00:05:04:203, filepos: 00001d800 Look after Clayton, okay?
timestamp: 00:05:05:947, filepos: 00001e800 I'll be back tonight.
timestamp: 00:05:07:957, filepos: 00001f800 Bye! Love you.
timestamp: 00:05:21:295, filepos: 000020800 Hey, Ace! What's up?
timestamp: 00:05:23:356, filepos: 000021800 Hey, how's it going?
timestamp: 00:05:24:640, filepos: 000022800 Remember what today is? The 3rd!
timestamp: 00:05:27:193, filepos: 000023800 Look over there!
timestamp: 00:05:28:369, filepos: 000024800 Where are they going?
timestamp: 00:05:28:361, filepos: 000025000 <???>
timestamp: 00:05:29:946, filepos: 000025800 Let's go see.
timestamp: 00:05:31:230, filepos: 000026000 I can't, man. I got Clayton.
Note the two "<???>": they are basically split subtitles (with the
previous one), which the dvdsub decoder is now supposed to reconstruct
with a previous commit. But also note that while the first chunk has
increasing timestamps,
timestamp: 00:05:02:018, filepos: 00001c800
timestamp: 00:05:02:035, filepos: 00001d000
...it's not the case of the second one (and this is not an exception in the
original file):
timestamp: 00:05:28:369, filepos: 000024800
timestamp: 00:05:28:361, filepos: 000025000
For the dvdsub decoder, they need to be "filepos'ed" ordered, but the
FFDemuxSubtitlesQueue is timestamps ordered, which is the reason of the
introduction of a sub sort method in the context, to allow giving
priority to the position, and then the timestamps. With that change, the
dvdsub decoder get fed with ordered packets.
Now the packet size estimation was also broken: the filepos differences
in the vobsub index defines the full data read between two subtitles
chunks, and it is necessary to take into account what is read by the
mpegps_read_pes_header() function since the length returned by that
function doesn't count the size of the data it reads. This is fixed with
the introduction of total_read, and {old,new}_pos. By doing this change,
we can drop the unreliable len16 heuristic and simplify the whole loop.
Note that mpegps_read_pes_header() often read more than one PES packet
(typically in one call it can read 0x1ba and 0x1be chunk along with the
relevant 0x1bd packet), which triggers the "total_read + pkt_size >
psize" check. This is an expected behaviour, which could be avoided by
having a more chunked version of mpegps_read_pes_header().
The latest change is the extraction of each stream into its own
subtitles queue. If we don't do this, the maximum size for a subtitle
chunk is broken, and the previous changes can not work. Having each
stream in a different queue requires some little adjustments in the
seek code of the demuxer.
This commit is only meaningful as a whole change and can not be easily
split. The FATE test changes because it uses the vobsub demuxer.
2013-09-29 20:05:14 +00:00
|
|
|
int i;
|
2012-09-03 00:51:00 +00:00
|
|
|
MpegDemuxContext *vobsub = s->priv_data;
|
avformat/vobsub: fix several issues.
Here is an extract of fate-samples/sub/vobsub.idx, with an additional
text at the end of each line to better identify each bitmap:
timestamp: 00:04:55:445, filepos: 00001b000 Ace!
timestamp: 00:05:00:049, filepos: 00001b800 Wake up, honey!
timestamp: 00:05:02:018, filepos: 00001c800 I gotta go to work.
timestamp: 00:05:02:035, filepos: 00001d000 <???>
timestamp: 00:05:04:203, filepos: 00001d800 Look after Clayton, okay?
timestamp: 00:05:05:947, filepos: 00001e800 I'll be back tonight.
timestamp: 00:05:07:957, filepos: 00001f800 Bye! Love you.
timestamp: 00:05:21:295, filepos: 000020800 Hey, Ace! What's up?
timestamp: 00:05:23:356, filepos: 000021800 Hey, how's it going?
timestamp: 00:05:24:640, filepos: 000022800 Remember what today is? The 3rd!
timestamp: 00:05:27:193, filepos: 000023800 Look over there!
timestamp: 00:05:28:369, filepos: 000024800 Where are they going?
timestamp: 00:05:28:361, filepos: 000025000 <???>
timestamp: 00:05:29:946, filepos: 000025800 Let's go see.
timestamp: 00:05:31:230, filepos: 000026000 I can't, man. I got Clayton.
Note the two "<???>": they are basically split subtitles (with the
previous one), which the dvdsub decoder is now supposed to reconstruct
with a previous commit. But also note that while the first chunk has
increasing timestamps,
timestamp: 00:05:02:018, filepos: 00001c800
timestamp: 00:05:02:035, filepos: 00001d000
...it's not the case of the second one (and this is not an exception in the
original file):
timestamp: 00:05:28:369, filepos: 000024800
timestamp: 00:05:28:361, filepos: 000025000
For the dvdsub decoder, they need to be "filepos'ed" ordered, but the
FFDemuxSubtitlesQueue is timestamps ordered, which is the reason of the
introduction of a sub sort method in the context, to allow giving
priority to the position, and then the timestamps. With that change, the
dvdsub decoder get fed with ordered packets.
Now the packet size estimation was also broken: the filepos differences
in the vobsub index defines the full data read between two subtitles
chunks, and it is necessary to take into account what is read by the
mpegps_read_pes_header() function since the length returned by that
function doesn't count the size of the data it reads. This is fixed with
the introduction of total_read, and {old,new}_pos. By doing this change,
we can drop the unreliable len16 heuristic and simplify the whole loop.
Note that mpegps_read_pes_header() often read more than one PES packet
(typically in one call it can read 0x1ba and 0x1be chunk along with the
relevant 0x1bd packet), which triggers the "total_read + pkt_size >
psize" check. This is an expected behaviour, which could be avoided by
having a more chunked version of mpegps_read_pes_header().
The latest change is the extraction of each stream into its own
subtitles queue. If we don't do this, the maximum size for a subtitle
chunk is broken, and the previous changes can not work. Having each
stream in a different queue requires some little adjustments in the
seek code of the demuxer.
This commit is only meaningful as a whole change and can not be easily
split. The FATE test changes because it uses the vobsub demuxer.
2013-09-29 20:05:14 +00:00
|
|
|
|
|
|
|
for (i = 0; i < s->nb_streams; i++)
|
|
|
|
ff_subtitles_queue_clean(&vobsub->q[i]);
|
2012-09-03 00:51:00 +00:00
|
|
|
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
|