2012-06-22 19:56:30 +00:00
|
|
|
/*
|
2013-09-08 10:36:57 +00:00
|
|
|
* Copyright (c) 2012-2013 Clément Bœsch <u pkh me>
|
2012-06-22 19:56:30 +00:00
|
|
|
*
|
|
|
|
* This file is part of FFmpeg.
|
|
|
|
*
|
|
|
|
* FFmpeg is free software; you can redistribute it and/or
|
|
|
|
* modify it under the terms of the GNU Lesser General Public
|
|
|
|
* License as published by the Free Software Foundation; either
|
|
|
|
* version 2.1 of the License, or (at your option) any later version.
|
|
|
|
*
|
|
|
|
* FFmpeg is distributed in the hope that it will be useful,
|
|
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
|
|
|
* Lesser General Public License for more details.
|
|
|
|
*
|
|
|
|
* You should have received a copy of the GNU Lesser General Public
|
|
|
|
* License along with FFmpeg; if not, write to the Free Software
|
|
|
|
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
|
|
|
|
*/
|
|
|
|
|
|
|
|
#include "avformat.h"
|
|
|
|
#include "subtitles.h"
|
2014-09-02 18:48:45 +00:00
|
|
|
#include "avio_internal.h"
|
2013-03-08 16:28:42 +00:00
|
|
|
#include "libavutil/avassert.h"
|
2012-06-17 09:43:09 +00:00
|
|
|
#include "libavutil/avstring.h"
|
2012-06-22 19:56:30 +00:00
|
|
|
|
2014-10-29 00:32:44 +00:00
|
|
|
void ff_text_init_avio(void *s, FFTextReader *r, AVIOContext *pb)
|
2014-09-02 18:48:45 +00:00
|
|
|
{
|
|
|
|
int i;
|
|
|
|
r->pb = pb;
|
|
|
|
r->buf_pos = r->buf_len = 0;
|
|
|
|
r->type = FF_UTF_8;
|
|
|
|
for (i = 0; i < 2; i++)
|
|
|
|
r->buf[r->buf_len++] = avio_r8(r->pb);
|
|
|
|
if (strncmp("\xFF\xFE", r->buf, 2) == 0) {
|
|
|
|
r->type = FF_UTF16LE;
|
|
|
|
r->buf_pos += 2;
|
|
|
|
} else if (strncmp("\xFE\xFF", r->buf, 2) == 0) {
|
|
|
|
r->type = FF_UTF16BE;
|
|
|
|
r->buf_pos += 2;
|
|
|
|
} else {
|
|
|
|
r->buf[r->buf_len++] = avio_r8(r->pb);
|
|
|
|
if (strncmp("\xEF\xBB\xBF", r->buf, 3) == 0) {
|
|
|
|
// UTF8
|
|
|
|
r->buf_pos += 3;
|
|
|
|
}
|
|
|
|
}
|
2014-10-29 00:32:44 +00:00
|
|
|
if (s && (r->type == FF_UTF16LE || r->type == FF_UTF16BE))
|
2014-10-29 17:29:43 +00:00
|
|
|
av_log(s, AV_LOG_INFO,
|
2014-10-29 00:32:44 +00:00
|
|
|
"UTF16 is automatically converted to UTF8, do not specify a character encoding\n");
|
2014-09-02 18:48:45 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
void ff_text_init_buf(FFTextReader *r, void *buf, size_t size)
|
|
|
|
{
|
|
|
|
memset(&r->buf_pb, 0, sizeof(r->buf_pb));
|
|
|
|
ffio_init_context(&r->buf_pb, buf, size, 0, NULL, NULL, NULL, NULL);
|
2014-10-29 00:32:44 +00:00
|
|
|
ff_text_init_avio(NULL, r, &r->buf_pb);
|
2014-09-02 18:48:45 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
int64_t ff_text_pos(FFTextReader *r)
|
|
|
|
{
|
|
|
|
return avio_tell(r->pb) - r->buf_len + r->buf_pos;
|
|
|
|
}
|
|
|
|
|
|
|
|
int ff_text_r8(FFTextReader *r)
|
|
|
|
{
|
|
|
|
uint32_t val;
|
|
|
|
uint8_t tmp;
|
|
|
|
if (r->buf_pos < r->buf_len)
|
|
|
|
return r->buf[r->buf_pos++];
|
|
|
|
if (r->type == FF_UTF16LE) {
|
|
|
|
GET_UTF16(val, avio_rl16(r->pb), return 0;)
|
|
|
|
} else if (r->type == FF_UTF16BE) {
|
|
|
|
GET_UTF16(val, avio_rb16(r->pb), return 0;)
|
|
|
|
} else {
|
|
|
|
return avio_r8(r->pb);
|
|
|
|
}
|
|
|
|
if (!val)
|
|
|
|
return 0;
|
|
|
|
r->buf_pos = 0;
|
|
|
|
r->buf_len = 0;
|
|
|
|
PUT_UTF8(val, tmp, r->buf[r->buf_len++] = tmp;)
|
|
|
|
return r->buf[r->buf_pos++]; // buf_len is at least 1
|
|
|
|
}
|
|
|
|
|
|
|
|
void ff_text_read(FFTextReader *r, char *buf, size_t size)
|
|
|
|
{
|
|
|
|
for ( ; size > 0; size--)
|
|
|
|
*buf++ = ff_text_r8(r);
|
|
|
|
}
|
|
|
|
|
2014-09-02 18:52:07 +00:00
|
|
|
int ff_text_eof(FFTextReader *r)
|
|
|
|
{
|
|
|
|
return r->buf_pos >= r->buf_len && avio_feof(r->pb);
|
|
|
|
}
|
|
|
|
|
|
|
|
int ff_text_peek_r8(FFTextReader *r)
|
|
|
|
{
|
|
|
|
int c;
|
|
|
|
if (r->buf_pos < r->buf_len)
|
|
|
|
return r->buf[r->buf_pos];
|
|
|
|
c = ff_text_r8(r);
|
|
|
|
if (!avio_feof(r->pb)) {
|
|
|
|
r->buf_pos = 0;
|
|
|
|
r->buf_len = 1;
|
|
|
|
r->buf[0] = c;
|
|
|
|
}
|
|
|
|
return c;
|
|
|
|
}
|
|
|
|
|
2012-06-22 19:56:30 +00:00
|
|
|
AVPacket *ff_subtitles_queue_insert(FFDemuxSubtitlesQueue *q,
|
2015-05-10 13:38:40 +00:00
|
|
|
const uint8_t *event, size_t len, int merge)
|
2012-06-22 19:56:30 +00:00
|
|
|
{
|
|
|
|
AVPacket *subs, *sub;
|
|
|
|
|
|
|
|
if (merge && q->nb_subs > 0) {
|
|
|
|
/* merge with previous event */
|
|
|
|
|
|
|
|
int old_len;
|
|
|
|
sub = &q->subs[q->nb_subs - 1];
|
|
|
|
old_len = sub->size;
|
|
|
|
if (av_grow_packet(sub, len) < 0)
|
|
|
|
return NULL;
|
|
|
|
memcpy(sub->data + old_len, event, len);
|
|
|
|
} else {
|
|
|
|
/* new event */
|
|
|
|
|
|
|
|
if (q->nb_subs >= INT_MAX/sizeof(*q->subs) - 1)
|
|
|
|
return NULL;
|
|
|
|
subs = av_fast_realloc(q->subs, &q->allocated_size,
|
|
|
|
(q->nb_subs + 1) * sizeof(*q->subs));
|
|
|
|
if (!subs)
|
|
|
|
return NULL;
|
|
|
|
q->subs = subs;
|
|
|
|
sub = &subs[q->nb_subs++];
|
|
|
|
if (av_new_packet(sub, len) < 0)
|
|
|
|
return NULL;
|
|
|
|
sub->flags |= AV_PKT_FLAG_KEY;
|
|
|
|
sub->pts = sub->dts = 0;
|
|
|
|
memcpy(sub->data, event, len);
|
|
|
|
}
|
|
|
|
return sub;
|
|
|
|
}
|
|
|
|
|
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
|
|
|
static int cmp_pkt_sub_ts_pos(const void *a, const void *b)
|
2012-06-22 19:56:30 +00:00
|
|
|
{
|
|
|
|
const AVPacket *s1 = a;
|
|
|
|
const AVPacket *s2 = b;
|
2015-11-01 15:43:56 +00:00
|
|
|
if (s1->pts == s2->pts)
|
|
|
|
return FFDIFFSIGN(s1->pos, s2->pos);
|
|
|
|
return FFDIFFSIGN(s1->pts , s2->pts);
|
2012-06-22 19:56:30 +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
|
|
|
static int cmp_pkt_sub_pos_ts(const void *a, const void *b)
|
|
|
|
{
|
|
|
|
const AVPacket *s1 = a;
|
|
|
|
const AVPacket *s2 = b;
|
|
|
|
if (s1->pos == s2->pos) {
|
|
|
|
if (s1->pts == s2->pts)
|
|
|
|
return 0;
|
|
|
|
return s1->pts > s2->pts ? 1 : -1;
|
|
|
|
}
|
|
|
|
return s1->pos > s2->pos ? 1 : -1;
|
|
|
|
}
|
|
|
|
|
2015-09-10 19:40:07 +00:00
|
|
|
static void drop_dups(void *log_ctx, FFDemuxSubtitlesQueue *q)
|
2015-09-10 19:17:44 +00:00
|
|
|
{
|
|
|
|
int i, drop = 0;
|
|
|
|
|
|
|
|
for (i = 1; i < q->nb_subs; i++) {
|
|
|
|
const int last_id = i - 1 - drop;
|
|
|
|
const AVPacket *last = &q->subs[last_id];
|
|
|
|
|
|
|
|
if (q->subs[i].pts == last->pts &&
|
|
|
|
q->subs[i].duration == last->duration &&
|
2015-09-10 19:39:13 +00:00
|
|
|
q->subs[i].stream_index == last->stream_index &&
|
2015-09-10 19:17:44 +00:00
|
|
|
!strcmp(q->subs[i].data, last->data)) {
|
|
|
|
|
2015-10-27 13:35:30 +00:00
|
|
|
av_packet_unref(&q->subs[i]);
|
2015-09-10 19:17:44 +00:00
|
|
|
drop++;
|
|
|
|
} else if (drop) {
|
|
|
|
q->subs[last_id + 1] = q->subs[i];
|
|
|
|
memset(&q->subs[i], 0, sizeof(q->subs[i])); // for safety
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if (drop) {
|
|
|
|
q->nb_subs -= drop;
|
2015-09-10 19:40:07 +00:00
|
|
|
av_log(log_ctx, AV_LOG_WARNING, "Dropping %d duplicated subtitle events\n", drop);
|
2015-09-10 19:17:44 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2015-09-10 19:40:07 +00:00
|
|
|
void ff_subtitles_queue_finalize(void *log_ctx, FFDemuxSubtitlesQueue *q)
|
2012-06-22 19:56:30 +00:00
|
|
|
{
|
|
|
|
int i;
|
|
|
|
|
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
|
|
|
qsort(q->subs, q->nb_subs, sizeof(*q->subs),
|
|
|
|
q->sort == SUB_SORT_TS_POS ? cmp_pkt_sub_ts_pos
|
|
|
|
: cmp_pkt_sub_pos_ts);
|
2012-06-22 19:56:30 +00:00
|
|
|
for (i = 0; i < q->nb_subs; i++)
|
2015-12-23 14:08:58 +00:00
|
|
|
if (q->subs[i].duration < 0 && i < q->nb_subs - 1)
|
2012-06-22 19:56:30 +00:00
|
|
|
q->subs[i].duration = q->subs[i + 1].pts - q->subs[i].pts;
|
2015-09-10 19:40:07 +00:00
|
|
|
|
2015-09-21 11:42:48 +00:00
|
|
|
if (!q->keep_duplicates)
|
|
|
|
drop_dups(log_ctx, q);
|
2012-06-22 19:56:30 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
int ff_subtitles_queue_read_packet(FFDemuxSubtitlesQueue *q, AVPacket *pkt)
|
|
|
|
{
|
|
|
|
AVPacket *sub = q->subs + q->current_sub_idx;
|
|
|
|
|
|
|
|
if (q->current_sub_idx == q->nb_subs)
|
|
|
|
return AVERROR_EOF;
|
2017-09-23 23:30:13 +00:00
|
|
|
if (av_packet_ref(pkt, sub) < 0) {
|
2013-08-30 18:57:04 +00:00
|
|
|
return AVERROR(ENOMEM);
|
|
|
|
}
|
2013-03-08 16:28:42 +00:00
|
|
|
|
2012-06-22 19:56:30 +00:00
|
|
|
pkt->dts = pkt->pts;
|
|
|
|
q->current_sub_idx++;
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2013-09-08 10:36:57 +00:00
|
|
|
static int search_sub_ts(const FFDemuxSubtitlesQueue *q, int64_t ts)
|
|
|
|
{
|
|
|
|
int s1 = 0, s2 = q->nb_subs - 1;
|
|
|
|
|
|
|
|
if (s2 < s1)
|
|
|
|
return AVERROR(ERANGE);
|
|
|
|
|
|
|
|
for (;;) {
|
|
|
|
int mid;
|
|
|
|
|
|
|
|
if (s1 == s2)
|
|
|
|
return s1;
|
|
|
|
if (s1 == s2 - 1)
|
|
|
|
return q->subs[s1].pts <= q->subs[s2].pts ? s1 : s2;
|
|
|
|
mid = (s1 + s2) / 2;
|
|
|
|
if (q->subs[mid].pts <= ts)
|
|
|
|
s1 = mid;
|
|
|
|
else
|
|
|
|
s2 = mid;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2012-11-23 20:40:46 +00:00
|
|
|
int ff_subtitles_queue_seek(FFDemuxSubtitlesQueue *q, AVFormatContext *s, int stream_index,
|
|
|
|
int64_t min_ts, int64_t ts, int64_t max_ts, int flags)
|
|
|
|
{
|
|
|
|
if (flags & AVSEEK_FLAG_BYTE) {
|
|
|
|
return AVERROR(ENOSYS);
|
|
|
|
} else if (flags & AVSEEK_FLAG_FRAME) {
|
|
|
|
if (ts < 0 || ts >= q->nb_subs)
|
|
|
|
return AVERROR(ERANGE);
|
|
|
|
q->current_sub_idx = ts;
|
|
|
|
} else {
|
2013-09-08 10:36:57 +00:00
|
|
|
int i, idx = search_sub_ts(q, ts);
|
2012-11-30 06:00:59 +00:00
|
|
|
int64_t ts_selected;
|
2013-09-08 10:36:57 +00:00
|
|
|
|
2012-11-23 20:40:46 +00:00
|
|
|
if (idx < 0)
|
2013-09-08 10:36:57 +00:00
|
|
|
return idx;
|
|
|
|
for (i = idx; i < q->nb_subs && q->subs[i].pts < min_ts; i++)
|
|
|
|
if (stream_index == -1 || q->subs[i].stream_index == stream_index)
|
|
|
|
idx = i;
|
|
|
|
for (i = idx; i > 0 && q->subs[i].pts > max_ts; i--)
|
|
|
|
if (stream_index == -1 || q->subs[i].stream_index == stream_index)
|
|
|
|
idx = i;
|
|
|
|
|
|
|
|
ts_selected = q->subs[idx].pts;
|
|
|
|
if (ts_selected < min_ts || ts_selected > max_ts)
|
2012-11-23 20:40:46 +00:00
|
|
|
return AVERROR(ERANGE);
|
2013-09-08 10:36:57 +00:00
|
|
|
|
2012-11-30 06:00:59 +00:00
|
|
|
/* look back in the latest subtitles for overlapping subtitles */
|
|
|
|
for (i = idx - 1; i >= 0; i--) {
|
2013-09-08 07:55:02 +00:00
|
|
|
int64_t pts = q->subs[i].pts;
|
2013-09-08 07:43:53 +00:00
|
|
|
if (q->subs[i].duration <= 0 ||
|
|
|
|
(stream_index != -1 && q->subs[i].stream_index != stream_index))
|
2012-11-30 06:00:59 +00:00
|
|
|
continue;
|
2013-09-08 07:55:02 +00:00
|
|
|
if (pts >= min_ts && pts > ts_selected - q->subs[i].duration)
|
2012-11-30 06:00:59 +00:00
|
|
|
idx = i;
|
|
|
|
else
|
|
|
|
break;
|
|
|
|
}
|
2013-09-08 07:43:53 +00:00
|
|
|
|
|
|
|
/* If the queue is used to store multiple subtitles streams (like with
|
|
|
|
* VobSub) and the stream index is not specified, we need to make sure
|
|
|
|
* to focus on the smallest file position offset for a same timestamp;
|
|
|
|
* queue is ordered by pts and then filepos, so we can take the first
|
|
|
|
* entry for a given timestamp. */
|
|
|
|
if (stream_index == -1)
|
|
|
|
while (idx > 0 && q->subs[idx - 1].pts == q->subs[idx].pts)
|
|
|
|
idx--;
|
|
|
|
|
2012-11-23 20:40:46 +00:00
|
|
|
q->current_sub_idx = idx;
|
|
|
|
}
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2012-06-22 19:56:30 +00:00
|
|
|
void ff_subtitles_queue_clean(FFDemuxSubtitlesQueue *q)
|
|
|
|
{
|
|
|
|
int i;
|
|
|
|
|
|
|
|
for (i = 0; i < q->nb_subs; i++)
|
2015-10-27 13:35:30 +00:00
|
|
|
av_packet_unref(&q->subs[i]);
|
2012-06-22 19:56:30 +00:00
|
|
|
av_freep(&q->subs);
|
|
|
|
q->nb_subs = q->allocated_size = q->current_sub_idx = 0;
|
|
|
|
}
|
2012-06-17 09:43:09 +00:00
|
|
|
|
2014-09-02 18:53:08 +00:00
|
|
|
int ff_smil_extract_next_text_chunk(FFTextReader *tr, AVBPrint *buf, char *c)
|
2012-06-17 09:43:09 +00:00
|
|
|
{
|
|
|
|
int i = 0;
|
|
|
|
char end_chr;
|
|
|
|
|
|
|
|
if (!*c) // cached char?
|
2014-09-02 18:53:08 +00:00
|
|
|
*c = ff_text_r8(tr);
|
2012-06-17 09:43:09 +00:00
|
|
|
if (!*c)
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
end_chr = *c == '<' ? '>' : '<';
|
|
|
|
do {
|
|
|
|
av_bprint_chars(buf, *c, 1);
|
2014-09-02 18:53:08 +00:00
|
|
|
*c = ff_text_r8(tr);
|
2012-06-17 09:43:09 +00:00
|
|
|
i++;
|
|
|
|
} while (*c != end_chr && *c);
|
|
|
|
if (end_chr == '>') {
|
|
|
|
av_bprint_chars(buf, '>', 1);
|
|
|
|
*c = 0;
|
|
|
|
}
|
|
|
|
return i;
|
|
|
|
}
|
|
|
|
|
|
|
|
const char *ff_smil_get_attr_ptr(const char *s, const char *attr)
|
|
|
|
{
|
|
|
|
int in_quotes = 0;
|
2015-05-10 13:38:40 +00:00
|
|
|
const size_t len = strlen(attr);
|
2012-06-17 09:43:09 +00:00
|
|
|
|
|
|
|
while (*s) {
|
|
|
|
while (*s) {
|
2013-03-03 10:17:50 +00:00
|
|
|
if (!in_quotes && av_isspace(*s))
|
2012-06-17 09:43:09 +00:00
|
|
|
break;
|
|
|
|
in_quotes ^= *s == '"'; // XXX: support escaping?
|
|
|
|
s++;
|
|
|
|
}
|
2013-03-03 10:17:50 +00:00
|
|
|
while (av_isspace(*s))
|
2012-06-17 09:43:09 +00:00
|
|
|
s++;
|
|
|
|
if (!av_strncasecmp(s, attr, len) && s[len] == '=')
|
|
|
|
return s + len + 1 + (s[len + 1] == '"');
|
|
|
|
}
|
|
|
|
return NULL;
|
|
|
|
}
|
2012-12-28 00:15:01 +00:00
|
|
|
|
|
|
|
static inline int is_eol(char c)
|
|
|
|
{
|
|
|
|
return c == '\r' || c == '\n';
|
|
|
|
}
|
|
|
|
|
2014-09-02 18:52:07 +00:00
|
|
|
void ff_subtitles_read_text_chunk(FFTextReader *tr, AVBPrint *buf)
|
2012-12-28 00:15:01 +00:00
|
|
|
{
|
2013-09-08 16:05:11 +00:00
|
|
|
char eol_buf[5], last_was_cr = 0;
|
2012-12-28 00:15:01 +00:00
|
|
|
int n = 0, i = 0, nb_eol = 0;
|
|
|
|
|
|
|
|
av_bprint_clear(buf);
|
|
|
|
|
|
|
|
for (;;) {
|
2014-09-02 18:52:07 +00:00
|
|
|
char c = ff_text_r8(tr);
|
2012-12-28 00:15:01 +00:00
|
|
|
|
|
|
|
if (!c)
|
|
|
|
break;
|
|
|
|
|
|
|
|
/* ignore all initial line breaks */
|
|
|
|
if (n == 0 && is_eol(c))
|
|
|
|
continue;
|
|
|
|
|
|
|
|
/* line break buffering: we don't want to add the trailing \r\n */
|
|
|
|
if (is_eol(c)) {
|
2013-09-08 16:05:11 +00:00
|
|
|
nb_eol += c == '\n' || last_was_cr;
|
2012-12-28 00:15:01 +00:00
|
|
|
if (nb_eol == 2)
|
|
|
|
break;
|
|
|
|
eol_buf[i++] = c;
|
|
|
|
if (i == sizeof(eol_buf) - 1)
|
|
|
|
break;
|
2013-09-08 16:05:11 +00:00
|
|
|
last_was_cr = c == '\r';
|
2012-12-28 00:15:01 +00:00
|
|
|
continue;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* only one line break followed by data: we flush the line breaks
|
|
|
|
* buffer */
|
|
|
|
if (i) {
|
|
|
|
eol_buf[i] = 0;
|
|
|
|
av_bprintf(buf, "%s", eol_buf);
|
|
|
|
i = nb_eol = 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
av_bprint_chars(buf, c, 1);
|
|
|
|
n++;
|
|
|
|
}
|
|
|
|
}
|
2014-09-02 18:52:07 +00:00
|
|
|
|
|
|
|
void ff_subtitles_read_chunk(AVIOContext *pb, AVBPrint *buf)
|
|
|
|
{
|
|
|
|
FFTextReader tr;
|
|
|
|
tr.buf_pos = tr.buf_len = 0;
|
|
|
|
tr.type = 0;
|
|
|
|
tr.pb = pb;
|
|
|
|
ff_subtitles_read_text_chunk(&tr, buf);
|
|
|
|
}
|
|
|
|
|
|
|
|
ptrdiff_t ff_subtitles_read_line(FFTextReader *tr, char *buf, size_t size)
|
|
|
|
{
|
|
|
|
size_t cur = 0;
|
|
|
|
if (!size)
|
|
|
|
return 0;
|
|
|
|
while (cur + 1 < size) {
|
|
|
|
unsigned char c = ff_text_r8(tr);
|
|
|
|
if (!c)
|
|
|
|
return ff_text_eof(tr) ? cur : AVERROR_INVALIDDATA;
|
|
|
|
if (c == '\r' || c == '\n')
|
|
|
|
break;
|
|
|
|
buf[cur++] = c;
|
|
|
|
buf[cur] = '\0';
|
|
|
|
}
|
2019-04-25 21:21:38 +00:00
|
|
|
while (ff_text_peek_r8(tr) == '\r')
|
2014-09-02 18:52:07 +00:00
|
|
|
ff_text_r8(tr);
|
|
|
|
if (ff_text_peek_r8(tr) == '\n')
|
|
|
|
ff_text_r8(tr);
|
|
|
|
return cur;
|
|
|
|
}
|