2011-01-16 18:03:08 +00:00
|
|
|
/*
|
2015-04-13 07:36:54 +00:00
|
|
|
* This file is part of mpv.
|
2011-01-16 18:03:08 +00:00
|
|
|
*
|
2015-04-13 07:36:54 +00:00
|
|
|
* mpv is free software; you can redistribute it and/or modify
|
2011-01-16 18:03:08 +00:00
|
|
|
* it under the terms of the GNU General Public License as published by
|
|
|
|
* the Free Software Foundation; either version 2 of the License, or
|
|
|
|
* (at your option) any later version.
|
|
|
|
*
|
2015-04-13 07:36:54 +00:00
|
|
|
* mpv is distributed in the hope that it will be useful,
|
2011-01-16 18:03:08 +00:00
|
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
|
|
* GNU General Public License for more details.
|
|
|
|
*
|
|
|
|
* You should have received a copy of the GNU General Public License along
|
2015-04-13 07:36:54 +00:00
|
|
|
* with mpv. If not, see <http://www.gnu.org/licenses/>.
|
2011-01-16 18:03:08 +00:00
|
|
|
*/
|
|
|
|
|
|
|
|
#include <stdlib.h>
|
|
|
|
#include <assert.h>
|
2011-01-18 13:33:36 +00:00
|
|
|
#include <string.h>
|
sub: fix crash with certain uses of --vf=sub
If, for some reason, the subtitle renderer attempts to render a
subtitle before SD_CTRL_SET_VIDEO_PARAMS was called, it passed a
value calculated from invalid values. This can happen with --vf=sub
and --start. The crash happens if 1. there was a subtitle packet that
falls into the timestamp of the rendered video frame, 2. the playloop
hasn't informed the subtitle decoder about the video resolution yet
(normally unneeded, because that is used for weird corner cases only,
so this code is a bit fuzzy), and 3. something actually requests a
frame to be drawn from the subtitle renderer, like with vf_sub.
The actual crash was due to passing NaN as pixel aspect to libass,
which then created glyphs with ridiculous sizes, involving a few
integer overflows and unchecked mallocs.
The sd_lavc.c and sd_spu.c cases probably don't crash, but I'm not
sure, and it's better fix them anyway.
Not bothering with sd_spu.c, this crap is for compatibility and will
be removed soon.
Note that this would have been no problem, had the code checked whether
SD_CTRL_SET_VIDEO_PARAMS was actually called. This commit adds such a
check (although it basically checks after using the parameters).
Regression since 49caa0a7 and 633fde4a.
2014-01-26 17:58:40 +00:00
|
|
|
#include <math.h>
|
2015-08-27 21:45:02 +00:00
|
|
|
#include <limits.h>
|
2011-01-16 18:03:08 +00:00
|
|
|
|
2013-07-15 00:28:46 +00:00
|
|
|
#include <libavutil/common.h>
|
2013-04-28 19:12:11 +00:00
|
|
|
#include <ass/ass.h>
|
|
|
|
|
2016-01-11 18:03:40 +00:00
|
|
|
#include "mpv_talloc.h"
|
2011-01-16 18:03:08 +00:00
|
|
|
|
2013-12-17 01:02:25 +00:00
|
|
|
#include "options/options.h"
|
2013-12-17 01:39:45 +00:00
|
|
|
#include "common/common.h"
|
|
|
|
#include "common/msg.h"
|
2015-12-26 17:34:18 +00:00
|
|
|
#include "demux/demux.h"
|
2013-07-14 23:48:25 +00:00
|
|
|
#include "video/csputils.h"
|
|
|
|
#include "video/mp_image.h"
|
2012-10-04 15:16:40 +00:00
|
|
|
#include "dec_sub.h"
|
2011-01-16 18:03:08 +00:00
|
|
|
#include "ass_mp.h"
|
|
|
|
#include "sd.h"
|
|
|
|
|
|
|
|
struct sd_ass_priv {
|
2015-12-26 17:34:18 +00:00
|
|
|
struct ass_library *ass_library;
|
|
|
|
struct ass_renderer *ass_renderer;
|
2011-01-16 18:03:08 +00:00
|
|
|
struct ass_track *ass_track;
|
2015-11-17 00:54:02 +00:00
|
|
|
struct ass_track *shadow_track; // for --sub-ass=no rendering
|
2013-07-14 23:48:25 +00:00
|
|
|
bool is_converted;
|
2015-12-18 00:54:14 +00:00
|
|
|
struct lavc_conv *converter;
|
2015-11-17 00:54:02 +00:00
|
|
|
bool on_top;
|
2016-06-30 19:38:50 +00:00
|
|
|
struct mp_ass_packer *packer;
|
|
|
|
struct sub_bitmap *bs;
|
2013-04-28 19:12:11 +00:00
|
|
|
char last_text[500];
|
2013-07-14 23:48:25 +00:00
|
|
|
struct mp_image_params video_params;
|
|
|
|
struct mp_image_params last_params;
|
2015-12-27 00:25:32 +00:00
|
|
|
double sub_speed, video_fps, frame_fps;
|
sub: do not clear subtitle list on seeking
This affects non-ASS text subtitles (those which go through libavcodec's
subtitle converter), which are muxed with video/audio. (Typically srt
subs in mkv.)
The problem is that seeking in the file can send a subtitle packet to
the decoder multiple times. These packets are interlaved with video,
and thus can't be all read when opening the file. Rather, subtitle
packets can essentially be randomly skipped or repeated (by seeking).
Until recently, this was solved by scanning the libass event list for
duplicates. Then our builtin srt-to-ass converter was removed, and
the problem was handled by fully clearing the subtitle list on each
seek.
This resulted in sub-seek not working properly for this type of file.
Since the subtitle list was cleared on seek, it was not possible to
do e.g. sub-seeks to subtitles before the current playback position.
Fix this by not clearing the list, and intead explicitly rejecting
duplicate packets. We use the packet file position was unique ID for
subtitles; this is confirmed working for most file formats (although
it is slightly risky - new demuxers may not necessarily set the file
position to something unique, or at all).
The list of seen packets is sorted, and the lookup uses binary search.
This is to avoid quadratic complexity when subtitles are added in
bulks, such as when opening a text subtitle file.
In some places, the code has to be adjusted to pass through the packet
file position correctly.
2015-12-17 23:51:57 +00:00
|
|
|
int64_t *seen_packets;
|
|
|
|
int num_seen_packets;
|
2015-12-22 01:35:15 +00:00
|
|
|
bool duration_unknown;
|
2011-01-16 18:03:08 +00:00
|
|
|
};
|
|
|
|
|
2013-07-14 23:48:25 +00:00
|
|
|
static void mangle_colors(struct sd *sd, struct sub_bitmaps *parts);
|
2015-11-17 00:54:02 +00:00
|
|
|
static void fill_plaintext(struct sd *sd, double pts);
|
2013-07-14 23:48:25 +00:00
|
|
|
|
2015-11-29 12:53:55 +00:00
|
|
|
// Add default styles, if the track does not have any styles yet.
|
|
|
|
// Apply style overrides if the user provides any.
|
|
|
|
static void mp_ass_add_default_styles(ASS_Track *track, struct MPOpts *opts)
|
|
|
|
{
|
|
|
|
if (opts->ass_styles_file && opts->ass_style_override)
|
|
|
|
ass_read_styles(track, opts->ass_styles_file, NULL);
|
|
|
|
|
|
|
|
if (track->n_styles == 0) {
|
|
|
|
if (!track->PlayResY) {
|
|
|
|
track->PlayResY = MP_ASS_FONT_PLAYRESY;
|
|
|
|
track->PlayResX = track->PlayResY * 4 / 3;
|
|
|
|
}
|
|
|
|
track->Kerning = true;
|
|
|
|
int sid = ass_alloc_style(track);
|
|
|
|
track->default_style = sid;
|
|
|
|
ASS_Style *style = track->styles + sid;
|
|
|
|
style->Name = strdup("Default");
|
2016-10-02 15:08:14 +00:00
|
|
|
mp_ass_set_style(style, track->PlayResY, opts->sub_style);
|
2015-11-29 12:53:55 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
if (opts->ass_style_override)
|
|
|
|
ass_process_force_style(track);
|
|
|
|
}
|
|
|
|
|
2015-12-26 17:34:18 +00:00
|
|
|
static const char *const font_mimetypes[] = {
|
|
|
|
"application/x-truetype-font",
|
|
|
|
"application/vnd.ms-opentype",
|
|
|
|
"application/x-font-ttf",
|
|
|
|
"application/x-font", // probably incorrect
|
|
|
|
NULL
|
|
|
|
};
|
|
|
|
|
|
|
|
static const char *const font_exts[] = {".ttf", ".ttc", ".otf", NULL};
|
|
|
|
|
|
|
|
static bool attachment_is_font(struct mp_log *log, struct demux_attachment *f)
|
|
|
|
{
|
|
|
|
if (!f->name || !f->type || !f->data || !f->data_size)
|
|
|
|
return false;
|
|
|
|
for (int n = 0; font_mimetypes[n]; n++) {
|
|
|
|
if (strcmp(font_mimetypes[n], f->type) == 0)
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
// fallback: match against file extension
|
|
|
|
char *ext = strlen(f->name) > 4 ? f->name + strlen(f->name) - 4 : "";
|
|
|
|
for (int n = 0; font_exts[n]; n++) {
|
|
|
|
if (strcasecmp(ext, font_exts[n]) == 0) {
|
|
|
|
mp_warn(log, "Loading font attachment '%s' with MIME type %s. "
|
|
|
|
"Assuming this is a broken Matroska file, which was "
|
|
|
|
"muxed without setting a correct font MIME type.\n",
|
|
|
|
f->name, f->type);
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void add_subtitle_fonts(struct sd *sd)
|
|
|
|
{
|
|
|
|
struct sd_ass_priv *ctx = sd->priv;
|
|
|
|
struct MPOpts *opts = sd->opts;
|
2016-04-30 12:26:08 +00:00
|
|
|
if (!opts->ass_enabled || !opts->use_embedded_fonts || !sd->attachments)
|
2015-12-26 17:34:18 +00:00
|
|
|
return;
|
2016-03-03 17:48:56 +00:00
|
|
|
for (int i = 0; i < sd->attachments->num_entries; i++) {
|
|
|
|
struct demux_attachment *f = &sd->attachments->entries[i];
|
2016-04-30 12:26:08 +00:00
|
|
|
if (attachment_is_font(sd->log, f))
|
2015-12-26 17:34:18 +00:00
|
|
|
ass_add_font(ctx->ass_library, f->name, f->data, f->data_size);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2015-12-26 17:35:36 +00:00
|
|
|
static void enable_output(struct sd *sd, bool enable)
|
|
|
|
{
|
|
|
|
struct sd_ass_priv *ctx = sd->priv;
|
|
|
|
if (enable == !!ctx->ass_renderer)
|
|
|
|
return;
|
|
|
|
if (ctx->ass_renderer) {
|
|
|
|
ass_renderer_done(ctx->ass_renderer);
|
|
|
|
ctx->ass_renderer = NULL;
|
|
|
|
} else {
|
|
|
|
ctx->ass_renderer = ass_renderer_init(ctx->ass_library);
|
|
|
|
|
2016-10-02 15:08:14 +00:00
|
|
|
mp_ass_configure_fonts(ctx->ass_renderer, sd->opts->sub_style,
|
2015-12-26 17:35:36 +00:00
|
|
|
sd->global, sd->log);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2015-12-27 00:25:32 +00:00
|
|
|
static void update_subtitle_speed(struct sd *sd)
|
|
|
|
{
|
|
|
|
struct MPOpts *opts = sd->opts;
|
|
|
|
struct sd_ass_priv *ctx = sd->priv;
|
|
|
|
ctx->sub_speed = 1.0;
|
|
|
|
|
|
|
|
if (ctx->video_fps > 0 && ctx->frame_fps > 0) {
|
|
|
|
MP_VERBOSE(sd, "Frame based format, dummy FPS: %f, video FPS: %f\n",
|
|
|
|
ctx->frame_fps, ctx->video_fps);
|
|
|
|
ctx->sub_speed *= ctx->frame_fps / ctx->video_fps;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (opts->sub_fps && ctx->video_fps)
|
|
|
|
ctx->sub_speed *= opts->sub_fps / ctx->video_fps;
|
|
|
|
|
|
|
|
ctx->sub_speed *= opts->sub_speed;
|
|
|
|
}
|
|
|
|
|
2013-06-01 17:44:12 +00:00
|
|
|
static int init(struct sd *sd)
|
2011-01-16 18:03:08 +00:00
|
|
|
{
|
2013-06-03 00:05:55 +00:00
|
|
|
struct MPOpts *opts = sd->opts;
|
2015-12-18 00:54:14 +00:00
|
|
|
struct sd_ass_priv *ctx = talloc_zero(sd, struct sd_ass_priv);
|
2013-06-01 17:44:12 +00:00
|
|
|
sd->priv = ctx;
|
2013-07-14 23:48:25 +00:00
|
|
|
|
2016-01-12 22:48:19 +00:00
|
|
|
char *extradata = sd->codec->extradata;
|
|
|
|
int extradata_size = sd->codec->extradata_size;
|
2015-12-18 00:54:14 +00:00
|
|
|
|
2016-01-12 22:48:19 +00:00
|
|
|
if (strcmp(sd->codec->codec, "ass") != 0) {
|
2015-12-18 00:54:14 +00:00
|
|
|
ctx->is_converted = true;
|
2016-01-12 22:48:19 +00:00
|
|
|
ctx->converter = lavc_conv_create(sd->log, sd->codec->codec, extradata,
|
2015-12-18 00:54:14 +00:00
|
|
|
extradata_size);
|
|
|
|
if (!ctx->converter)
|
|
|
|
return -1;
|
|
|
|
extradata = lavc_conv_get_extradata(ctx->converter);
|
|
|
|
extradata_size = extradata ? strlen(extradata) : 0;
|
2015-12-22 01:35:15 +00:00
|
|
|
|
|
|
|
if (strcmp(sd->codec->codec, "eia_608") == 0)
|
|
|
|
ctx->duration_unknown = 1;
|
2015-12-18 00:54:14 +00:00
|
|
|
}
|
2013-07-14 23:48:25 +00:00
|
|
|
|
2015-12-26 17:34:18 +00:00
|
|
|
ctx->ass_library = mp_ass_init(sd->global, sd->log);
|
|
|
|
|
|
|
|
add_subtitle_fonts(sd);
|
|
|
|
|
|
|
|
if (opts->ass_style_override)
|
|
|
|
ass_set_style_overrides(ctx->ass_library, opts->ass_force_style_list);
|
2015-07-06 19:55:37 +00:00
|
|
|
|
2015-12-26 17:34:18 +00:00
|
|
|
ctx->ass_track = ass_new_track(ctx->ass_library);
|
2014-03-15 21:17:51 +00:00
|
|
|
if (!ctx->is_converted)
|
|
|
|
ctx->ass_track->track_type = TRACK_TYPE_ASS;
|
2011-01-16 18:03:08 +00:00
|
|
|
|
2015-12-26 17:34:18 +00:00
|
|
|
ctx->shadow_track = ass_new_track(ctx->ass_library);
|
2015-11-17 00:54:02 +00:00
|
|
|
ctx->shadow_track->PlayResX = 384;
|
|
|
|
ctx->shadow_track->PlayResY = 288;
|
|
|
|
mp_ass_add_default_styles(ctx->shadow_track, opts);
|
|
|
|
|
2015-12-18 00:54:14 +00:00
|
|
|
if (extradata)
|
|
|
|
ass_process_codec_private(ctx->ass_track, extradata, extradata_size);
|
2013-06-01 17:54:18 +00:00
|
|
|
|
2013-06-03 00:05:55 +00:00
|
|
|
mp_ass_add_default_styles(ctx->ass_track, opts);
|
|
|
|
|
2015-12-31 15:43:57 +00:00
|
|
|
#if LIBASS_VERSION >= 0x01302000
|
|
|
|
ass_set_check_readorder(ctx->ass_track, sd->opts->sub_clear_on_seek ? 0 : 1);
|
|
|
|
#endif
|
|
|
|
|
2016-01-12 22:48:19 +00:00
|
|
|
ctx->frame_fps = sd->codec->frame_based;
|
2015-12-27 00:25:32 +00:00
|
|
|
update_subtitle_speed(sd);
|
2015-12-05 22:56:28 +00:00
|
|
|
|
2015-12-26 17:35:36 +00:00
|
|
|
enable_output(sd, true);
|
|
|
|
|
2016-06-30 19:38:50 +00:00
|
|
|
ctx->packer = mp_ass_packer_alloc(ctx);
|
|
|
|
|
2012-08-16 15:21:21 +00:00
|
|
|
return 0;
|
2011-01-16 18:03:08 +00:00
|
|
|
}
|
|
|
|
|
sub: do not clear subtitle list on seeking
This affects non-ASS text subtitles (those which go through libavcodec's
subtitle converter), which are muxed with video/audio. (Typically srt
subs in mkv.)
The problem is that seeking in the file can send a subtitle packet to
the decoder multiple times. These packets are interlaved with video,
and thus can't be all read when opening the file. Rather, subtitle
packets can essentially be randomly skipped or repeated (by seeking).
Until recently, this was solved by scanning the libass event list for
duplicates. Then our builtin srt-to-ass converter was removed, and
the problem was handled by fully clearing the subtitle list on each
seek.
This resulted in sub-seek not working properly for this type of file.
Since the subtitle list was cleared on seek, it was not possible to
do e.g. sub-seeks to subtitles before the current playback position.
Fix this by not clearing the list, and intead explicitly rejecting
duplicate packets. We use the packet file position was unique ID for
subtitles; this is confirmed working for most file formats (although
it is slightly risky - new demuxers may not necessarily set the file
position to something unique, or at all).
The list of seen packets is sorted, and the lookup uses binary search.
This is to avoid quadratic complexity when subtitles are added in
bulks, such as when opening a text subtitle file.
In some places, the code has to be adjusted to pass through the packet
file position correctly.
2015-12-17 23:51:57 +00:00
|
|
|
// Test if the packet with the given file position (used as unique ID) was
|
|
|
|
// already consumed. Return false if the packet is new (and add it to the
|
|
|
|
// internal list), and return true if it was already seen.
|
|
|
|
static bool check_packet_seen(struct sd *sd, int64_t pos)
|
|
|
|
{
|
|
|
|
struct sd_ass_priv *priv = sd->priv;
|
|
|
|
int a = 0;
|
|
|
|
int b = priv->num_seen_packets;
|
|
|
|
while (a < b) {
|
|
|
|
int mid = a + (b - a) / 2;
|
|
|
|
int64_t val = priv->seen_packets[mid];
|
|
|
|
if (pos == val)
|
|
|
|
return true;
|
|
|
|
if (pos > val) {
|
|
|
|
a = mid + 1;
|
|
|
|
} else {
|
|
|
|
b = mid;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
MP_TARRAY_INSERT_AT(priv, priv->seen_packets, priv->num_seen_packets, a, pos);
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
2016-03-04 23:13:30 +00:00
|
|
|
#define UNKNOWN_DURATION (INT_MAX / 1000)
|
|
|
|
|
2013-06-01 17:44:12 +00:00
|
|
|
static void decode(struct sd *sd, struct demux_packet *packet)
|
2011-01-16 18:03:08 +00:00
|
|
|
{
|
2013-06-01 17:44:12 +00:00
|
|
|
struct sd_ass_priv *ctx = sd->priv;
|
2011-01-18 13:33:36 +00:00
|
|
|
ASS_Track *track = ctx->ass_track;
|
2015-12-18 00:54:14 +00:00
|
|
|
if (ctx->converter) {
|
2015-12-22 01:35:15 +00:00
|
|
|
if (!sd->opts->sub_clear_on_seek && packet->pos >= 0 &&
|
|
|
|
check_packet_seen(sd, packet->pos))
|
2015-12-18 00:54:14 +00:00
|
|
|
return;
|
2016-03-04 23:13:30 +00:00
|
|
|
if (packet->duration < 0) {
|
|
|
|
if (!ctx->duration_unknown) {
|
|
|
|
MP_WARN(sd, "Subtitle with unknown duration.\n");
|
|
|
|
ctx->duration_unknown = true;
|
|
|
|
}
|
|
|
|
packet->duration = UNKNOWN_DURATION;
|
|
|
|
}
|
2015-12-18 00:54:14 +00:00
|
|
|
char **r = lavc_conv_decode(ctx->converter, packet);
|
2017-02-02 09:53:19 +00:00
|
|
|
for (int n = 0; r && r[n]; n++) {
|
|
|
|
char *ass_line = r[n];
|
|
|
|
if (sd->opts->sub_filter_SDH)
|
|
|
|
ass_line = filter_SDH(sd, track->event_format, 0, ass_line, 0);
|
|
|
|
if (ass_line)
|
|
|
|
ass_process_data(track, ass_line, strlen(ass_line));
|
|
|
|
if (sd->opts->sub_filter_SDH)
|
|
|
|
talloc_free(ass_line);
|
|
|
|
}
|
2015-12-22 01:35:15 +00:00
|
|
|
if (ctx->duration_unknown) {
|
|
|
|
for (int n = 0; n < track->n_events - 1; n++) {
|
2016-03-04 23:13:30 +00:00
|
|
|
if (track->events[n].Duration == UNKNOWN_DURATION * 1000) {
|
|
|
|
track->events[n].Duration = track->events[n + 1].Start -
|
|
|
|
track->events[n].Start;
|
|
|
|
}
|
2015-12-22 01:35:15 +00:00
|
|
|
}
|
|
|
|
}
|
2015-12-18 00:54:14 +00:00
|
|
|
} else {
|
sub: do not clear subtitle list on seeking
This affects non-ASS text subtitles (those which go through libavcodec's
subtitle converter), which are muxed with video/audio. (Typically srt
subs in mkv.)
The problem is that seeking in the file can send a subtitle packet to
the decoder multiple times. These packets are interlaved with video,
and thus can't be all read when opening the file. Rather, subtitle
packets can essentially be randomly skipped or repeated (by seeking).
Until recently, this was solved by scanning the libass event list for
duplicates. Then our builtin srt-to-ass converter was removed, and
the problem was handled by fully clearing the subtitle list on each
seek.
This resulted in sub-seek not working properly for this type of file.
Since the subtitle list was cleared on seek, it was not possible to
do e.g. sub-seeks to subtitles before the current playback position.
Fix this by not clearing the list, and intead explicitly rejecting
duplicate packets. We use the packet file position was unique ID for
subtitles; this is confirmed working for most file formats (although
it is slightly risky - new demuxers may not necessarily set the file
position to something unique, or at all).
The list of seen packets is sorted, and the lookup uses binary search.
This is to avoid quadratic complexity when subtitles are added in
bulks, such as when opening a text subtitle file.
In some places, the code has to be adjusted to pass through the packet
file position correctly.
2015-12-17 23:51:57 +00:00
|
|
|
// Note that for this packet format, libass has an internal mechanism
|
|
|
|
// for discarding duplicate (already seen) packets.
|
2017-02-02 09:53:19 +00:00
|
|
|
char *ass_line = packet->buffer;
|
|
|
|
int ass_len = packet->len;
|
|
|
|
if (sd->opts->sub_filter_SDH) {
|
|
|
|
ass_line = filter_SDH(sd, track->event_format, 1, ass_line, ass_len);
|
|
|
|
ass_len = strlen(ass_line);
|
|
|
|
}
|
|
|
|
if (ass_line)
|
|
|
|
ass_process_chunk(track, ass_line, ass_len,
|
|
|
|
llrint(packet->pts * 1000),
|
|
|
|
llrint(packet->duration * 1000));
|
|
|
|
if (sd->opts->sub_filter_SDH)
|
|
|
|
talloc_free(ass_line);
|
2013-06-23 20:10:10 +00:00
|
|
|
}
|
2011-01-18 13:33:36 +00:00
|
|
|
}
|
|
|
|
|
2015-11-17 00:54:02 +00:00
|
|
|
static void configure_ass(struct sd *sd, struct mp_osd_res *dim,
|
|
|
|
bool converted, ASS_Track *track)
|
2015-02-24 14:49:26 +00:00
|
|
|
{
|
2015-02-24 15:17:10 +00:00
|
|
|
struct MPOpts *opts = sd->opts;
|
2015-12-26 17:34:18 +00:00
|
|
|
struct sd_ass_priv *ctx = sd->priv;
|
|
|
|
ASS_Renderer *priv = ctx->ass_renderer;
|
2015-02-24 15:17:10 +00:00
|
|
|
|
2015-02-24 14:49:26 +00:00
|
|
|
ass_set_frame_size(priv, dim->w, dim->h);
|
|
|
|
ass_set_margins(priv, dim->mt, dim->mb, dim->ml, dim->mr);
|
|
|
|
|
|
|
|
bool set_use_margins = false;
|
|
|
|
int set_sub_pos = 0;
|
|
|
|
float set_line_spacing = 0;
|
|
|
|
float set_font_scale = 1;
|
|
|
|
int set_hinting = 0;
|
|
|
|
bool set_scale_with_window = false;
|
|
|
|
bool set_scale_by_window = true;
|
|
|
|
bool total_override = false;
|
|
|
|
// With forced overrides, apply the --sub-* specific options
|
2015-11-17 00:54:02 +00:00
|
|
|
if (converted || opts->ass_style_override == 3) {
|
2015-02-24 14:49:26 +00:00
|
|
|
set_scale_with_window = opts->sub_scale_with_window;
|
|
|
|
set_use_margins = opts->sub_use_margins;
|
|
|
|
set_scale_by_window = opts->sub_scale_by_window;
|
|
|
|
total_override = true;
|
|
|
|
} else {
|
|
|
|
set_scale_with_window = opts->ass_scale_with_window;
|
|
|
|
set_use_margins = opts->ass_use_margins;
|
|
|
|
}
|
2015-11-17 00:54:02 +00:00
|
|
|
if (converted || opts->ass_style_override) {
|
2015-02-24 14:49:26 +00:00
|
|
|
set_sub_pos = 100 - opts->sub_pos;
|
|
|
|
set_line_spacing = opts->ass_line_spacing;
|
|
|
|
set_hinting = opts->ass_hinting;
|
|
|
|
set_font_scale = opts->sub_scale;
|
|
|
|
}
|
|
|
|
if (set_scale_with_window) {
|
|
|
|
int vidh = dim->h - (dim->mt + dim->mb);
|
|
|
|
set_font_scale *= dim->h / (float)MPMAX(vidh, 1);
|
|
|
|
}
|
|
|
|
if (!set_scale_by_window) {
|
|
|
|
double factor = dim->h / 720.0;
|
|
|
|
if (factor != 0.0)
|
|
|
|
set_font_scale /= factor;
|
|
|
|
}
|
|
|
|
ass_set_use_margins(priv, set_use_margins);
|
|
|
|
ass_set_line_position(priv, set_sub_pos);
|
|
|
|
ass_set_shaper(priv, opts->ass_shaper);
|
|
|
|
int set_force_flags = 0;
|
|
|
|
if (total_override)
|
|
|
|
set_force_flags |= ASS_OVERRIDE_BIT_STYLE | ASS_OVERRIDE_BIT_FONT_SIZE;
|
|
|
|
if (opts->ass_style_override == 4)
|
|
|
|
set_force_flags |= ASS_OVERRIDE_BIT_FONT_SIZE;
|
2016-09-07 12:11:45 +00:00
|
|
|
#if LIBASS_VERSION >= 0x01201001
|
2016-09-07 11:42:55 +00:00
|
|
|
if (converted)
|
|
|
|
set_force_flags |= ASS_OVERRIDE_BIT_ALIGNMENT;
|
2017-02-01 12:19:09 +00:00
|
|
|
#endif
|
|
|
|
#ifdef ASS_JUSTIFY_AUTO
|
|
|
|
if ((converted || opts->ass_style_override) && opts->ass_justify)
|
|
|
|
set_force_flags |= ASS_OVERRIDE_BIT_JUSTIFY;
|
2016-09-07 12:11:45 +00:00
|
|
|
#endif
|
2015-02-24 14:49:26 +00:00
|
|
|
ass_set_selective_style_override_enabled(priv, set_force_flags);
|
|
|
|
ASS_Style style = {0};
|
2016-10-02 15:08:14 +00:00
|
|
|
mp_ass_set_style(&style, 288, opts->sub_style);
|
2015-02-24 14:49:26 +00:00
|
|
|
ass_set_selective_style_override(priv, &style);
|
|
|
|
free(style.FontName);
|
2015-11-17 00:54:02 +00:00
|
|
|
if (converted && track->default_style < track->n_styles) {
|
2015-02-24 15:17:10 +00:00
|
|
|
mp_ass_set_style(track->styles + track->default_style,
|
2016-10-02 15:08:14 +00:00
|
|
|
track->PlayResY, opts->sub_style);
|
2015-02-24 15:17:10 +00:00
|
|
|
}
|
2015-02-24 14:49:26 +00:00
|
|
|
ass_set_font_scale(priv, set_font_scale);
|
|
|
|
ass_set_hinting(priv, set_hinting);
|
|
|
|
ass_set_line_spacing(priv, set_line_spacing);
|
|
|
|
}
|
|
|
|
|
2015-12-06 17:22:30 +00:00
|
|
|
static bool has_overrides(char *s)
|
|
|
|
{
|
|
|
|
if (!s)
|
|
|
|
return false;
|
|
|
|
return strstr(s, "\\pos") || strstr(s, "\\move") || strstr(s, "\\clip") ||
|
|
|
|
strstr(s, "\\iclip") || strstr(s, "\\org") || strstr(s, "\\p");
|
|
|
|
}
|
|
|
|
|
2015-12-05 22:56:07 +00:00
|
|
|
#define END(ev) ((ev)->Start + (ev)->Duration)
|
|
|
|
|
|
|
|
static long long find_timestamp(struct sd *sd, double pts)
|
|
|
|
{
|
|
|
|
struct sd_ass_priv *priv = sd->priv;
|
|
|
|
if (pts == MP_NOPTS_VALUE)
|
|
|
|
return 0;
|
|
|
|
|
2015-12-05 22:56:28 +00:00
|
|
|
pts /= priv->sub_speed;
|
|
|
|
|
2015-12-05 22:56:07 +00:00
|
|
|
long long ts = llrint(pts * 1000);
|
|
|
|
|
2017-03-15 00:54:55 +00:00
|
|
|
if (!sd->opts->sub_fix_timing || sd->opts->ass_style_override == 0)
|
2015-12-05 22:56:07 +00:00
|
|
|
return ts;
|
|
|
|
|
|
|
|
// Try to fix small gaps and overlaps.
|
|
|
|
ASS_Track *track = priv->ass_track;
|
|
|
|
int threshold = SUB_GAP_THRESHOLD * 1000;
|
|
|
|
int keep = SUB_GAP_KEEP * 1000;
|
|
|
|
|
|
|
|
// Find the "current" event.
|
|
|
|
ASS_Event *ev[2] = {0};
|
|
|
|
int n_ev = 0;
|
|
|
|
for (int n = 0; n < track->n_events; n++) {
|
|
|
|
ASS_Event *event = &track->events[n];
|
|
|
|
if (ts >= event->Start - threshold && ts <= END(event) + threshold) {
|
|
|
|
if (n_ev >= MP_ARRAY_SIZE(ev))
|
|
|
|
return ts; // multiple overlaps - give up (probably complex subs)
|
|
|
|
ev[n_ev++] = event;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if (n_ev != 2)
|
|
|
|
return ts;
|
|
|
|
|
|
|
|
// Simple/minor heuristic against destroying typesetting.
|
2015-12-06 17:22:30 +00:00
|
|
|
if (ev[0]->Style != ev[1]->Style || has_overrides(ev[0]->Text) ||
|
|
|
|
has_overrides(ev[1]->Text))
|
2015-12-05 22:56:07 +00:00
|
|
|
return ts;
|
|
|
|
|
|
|
|
// Sort by start timestamps.
|
|
|
|
if (ev[0]->Start > ev[1]->Start)
|
|
|
|
MPSWAP(ASS_Event*, ev[0], ev[1]);
|
|
|
|
|
|
|
|
// We want to fix partial overlaps only.
|
|
|
|
if (END(ev[0]) >= END(ev[1]))
|
|
|
|
return ts;
|
|
|
|
|
|
|
|
if (ev[0]->Duration < keep || ev[1]->Duration < keep)
|
|
|
|
return ts;
|
|
|
|
|
|
|
|
// Gap between the events -> move ts to show the end of the first event.
|
|
|
|
if (ts >= END(ev[0]) && ts < ev[1]->Start && END(ev[0]) < ev[1]->Start &&
|
|
|
|
END(ev[0]) + threshold >= ev[1]->Start)
|
|
|
|
return END(ev[0]) - 1;
|
|
|
|
|
|
|
|
// Overlap -> move ts to the (exclusive) end of the first event.
|
|
|
|
// Relies on the fact that the ASS_Renderer has no overlap registered, even
|
|
|
|
// if there is one. This happens to work because we never render the
|
|
|
|
// overlapped state, and libass never resolves a collision.
|
|
|
|
if (ts >= ev[1]->Start && ts <= END(ev[0]) && END(ev[0]) > ev[1]->Start &&
|
|
|
|
END(ev[0]) <= ev[1]->Start + threshold)
|
|
|
|
return END(ev[0]);
|
|
|
|
|
|
|
|
return ts;
|
|
|
|
}
|
|
|
|
|
|
|
|
#undef END
|
|
|
|
|
2016-07-03 16:33:28 +00:00
|
|
|
static void get_bitmaps(struct sd *sd, struct mp_osd_res dim, int format,
|
|
|
|
double pts, struct sub_bitmaps *res)
|
2012-08-25 18:22:39 +00:00
|
|
|
{
|
2013-06-01 17:44:12 +00:00
|
|
|
struct sd_ass_priv *ctx = sd->priv;
|
|
|
|
struct MPOpts *opts = sd->opts;
|
2016-04-30 12:25:23 +00:00
|
|
|
bool no_ass = !opts->ass_enabled || ctx->on_top ||
|
|
|
|
opts->ass_style_override == 5;
|
2015-11-17 00:54:02 +00:00
|
|
|
bool converted = ctx->is_converted || no_ass;
|
|
|
|
ASS_Track *track = no_ass ? ctx->shadow_track : ctx->ass_track;
|
2015-12-26 17:35:36 +00:00
|
|
|
ASS_Renderer *renderer = ctx->ass_renderer;
|
2012-08-25 18:22:39 +00:00
|
|
|
|
2015-12-26 17:35:36 +00:00
|
|
|
if (pts == MP_NOPTS_VALUE || !renderer)
|
2012-08-25 18:22:39 +00:00
|
|
|
return;
|
|
|
|
|
VO, sub: refactor
Remove VFCTRL_DRAW_OSD, VFCAP_EOSD_FILTER, VFCAP_EOSD_RGBA, VFCAP_EOSD,
VOCTRL_DRAW_EOSD, VOCTRL_GET_EOSD_RES, VOCTRL_QUERY_EOSD_FORMAT.
Remove draw_osd_with_eosd(), which rendered the OSD by calling
VOCTRL_DRAW_EOSD. Change VOs to call osd_draw() directly, which takes
a callback as argument. (This basically works like the old OSD API,
except multiple OSD bitmap formats are supported and caching is
possible.)
Remove all mentions of "eosd". It's simply "osd" now.
Make OSD size per-OSD-object, as they can be different when using
vf_sub. Include display_par/video_par in resolution change detection.
Fix the issue with margin borders in vo_corevideo.
2012-10-19 17:25:18 +00:00
|
|
|
double scale = dim.display_par;
|
2015-11-17 00:54:02 +00:00
|
|
|
if (!converted && (!opts->ass_style_override ||
|
|
|
|
opts->ass_vsfilter_aspect_compat))
|
2013-07-16 21:03:59 +00:00
|
|
|
{
|
2013-11-01 12:15:59 +00:00
|
|
|
// Let's use the original video PAR for vsfilter compatibility:
|
2015-12-19 19:04:31 +00:00
|
|
|
double par = ctx->video_params.p_w / (double)ctx->video_params.p_h;
|
sub: fix crash with certain uses of --vf=sub
If, for some reason, the subtitle renderer attempts to render a
subtitle before SD_CTRL_SET_VIDEO_PARAMS was called, it passed a
value calculated from invalid values. This can happen with --vf=sub
and --start. The crash happens if 1. there was a subtitle packet that
falls into the timestamp of the rendered video frame, 2. the playloop
hasn't informed the subtitle decoder about the video resolution yet
(normally unneeded, because that is used for weird corner cases only,
so this code is a bit fuzzy), and 3. something actually requests a
frame to be drawn from the subtitle renderer, like with vf_sub.
The actual crash was due to passing NaN as pixel aspect to libass,
which then created glyphs with ridiculous sizes, involving a few
integer overflows and unchecked mallocs.
The sd_lavc.c and sd_spu.c cases probably don't crash, but I'm not
sure, and it's better fix them anyway.
Not bothering with sd_spu.c, this crap is for compatibility and will
be removed soon.
Note that this would have been no problem, had the code checked whether
SD_CTRL_SET_VIDEO_PARAMS was actually called. This commit adds such a
check (although it basically checks after using the parameters).
Regression since 49caa0a7 and 633fde4a.
2014-01-26 17:58:40 +00:00
|
|
|
if (isnormal(par))
|
2015-12-19 19:04:31 +00:00
|
|
|
scale *= par;
|
2013-07-16 21:03:59 +00:00
|
|
|
}
|
2015-11-17 00:54:02 +00:00
|
|
|
configure_ass(sd, &dim, converted, track);
|
2015-02-25 15:48:01 +00:00
|
|
|
ass_set_pixel_aspect(renderer, scale);
|
2015-11-17 00:54:02 +00:00
|
|
|
if (!converted && (!opts->ass_style_override ||
|
|
|
|
opts->ass_vsfilter_blur_compat))
|
2013-06-30 16:46:29 +00:00
|
|
|
{
|
|
|
|
ass_set_storage_size(renderer, ctx->video_params.w, ctx->video_params.h);
|
|
|
|
} else {
|
|
|
|
ass_set_storage_size(renderer, 0, 0);
|
|
|
|
}
|
2015-12-22 01:35:15 +00:00
|
|
|
long long ts = find_timestamp(sd, pts);
|
|
|
|
if (ctx->duration_unknown && pts != MP_NOPTS_VALUE) {
|
|
|
|
mp_ass_flush_old_events(track, ts);
|
2016-03-04 23:13:30 +00:00
|
|
|
ctx->num_seen_packets = 0;
|
sub: make preloading more robust
Subtitles can be preloaded, which means they're fully read and copied
into ASS_Track. This in turn is mainly for the sake of being able to do
subtitle seeking (when it comes down to it, subtitle seeking is the
cause for most trouble here).
Commit a714f8e92 broke preloaded subtitles which have events with
unknown duration, such as some MicroDVD samples. The event list gets
cleared on every seek, so the property of being preloaded obviously gets
lost.
Fix this by moving most of the preloading logic to dec_sub.c. If the
subtitle list gets cleared, they are not considered preloaded anymore,
and the logic for demuxed subtitles is used.
As another minor thing, preloadeding subtitles did neither disable the
demux stream, nor did it discard packets. Thus you could get queue
overflows in theory (harmless, but annoying). Fix this by explicitly
discarding packets in preloaded mode.
In summary, now the only difference between preloaded and normal
demuxing are:
1. a seek is issued, and all packets are read on start
2. during playback, discard the packets instead of feeding them to the
subtitle decoder
This is still petty annoying. It would be nice if maintaining the
subtitle index (and maybe a subtitle packet cache for instant subtitle
presentation when seeking back) could be maintained in the demuxer
instead. Half of all file formats with interleaved subtitles have
this anyway (mp4, mkv muxed with newer mkvmerge).
2016-03-06 13:50:36 +00:00
|
|
|
sd->preload_ok = false;
|
2015-12-22 01:35:15 +00:00
|
|
|
}
|
2016-03-08 19:49:33 +00:00
|
|
|
|
2015-11-17 00:54:02 +00:00
|
|
|
if (no_ass)
|
|
|
|
fill_plaintext(sd, pts);
|
2016-03-08 19:49:33 +00:00
|
|
|
|
2016-06-30 19:38:50 +00:00
|
|
|
int changed;
|
|
|
|
ASS_Image *imgs = ass_render_frame(renderer, track, ts, &changed);
|
2016-07-03 16:33:28 +00:00
|
|
|
mp_ass_packer_pack(ctx->packer, &imgs, 1, changed, format, res);
|
2013-07-14 23:48:25 +00:00
|
|
|
|
2016-06-30 19:38:50 +00:00
|
|
|
if (!converted && res->num_parts > 0) {
|
|
|
|
// mangle_colors() modifies the color field, so copy the thing.
|
|
|
|
MP_TARRAY_GROW(ctx, ctx->bs, res->num_parts);
|
|
|
|
memcpy(ctx->bs, res->parts, sizeof(ctx->bs[0]) * res->num_parts);
|
|
|
|
res->parts = ctx->bs;
|
2016-03-08 19:49:33 +00:00
|
|
|
|
2016-06-30 19:38:50 +00:00
|
|
|
mangle_colors(sd, res);
|
|
|
|
}
|
2012-08-25 18:22:39 +00:00
|
|
|
}
|
|
|
|
|
2013-04-28 19:12:11 +00:00
|
|
|
struct buf {
|
|
|
|
char *start;
|
|
|
|
int size;
|
|
|
|
int len;
|
|
|
|
};
|
|
|
|
|
|
|
|
static void append(struct buf *b, char c)
|
|
|
|
{
|
|
|
|
if (b->len < b->size) {
|
|
|
|
b->start[b->len] = c;
|
|
|
|
b->len++;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
static void ass_to_plaintext(struct buf *b, const char *in)
|
|
|
|
{
|
|
|
|
bool in_tag = false;
|
2015-02-12 11:18:19 +00:00
|
|
|
const char *open_tag_pos = NULL;
|
2013-04-28 19:12:11 +00:00
|
|
|
bool in_drawing = false;
|
|
|
|
while (*in) {
|
|
|
|
if (in_tag) {
|
|
|
|
if (in[0] == '}') {
|
|
|
|
in += 1;
|
|
|
|
in_tag = false;
|
|
|
|
} else if (in[0] == '\\' && in[1] == 'p') {
|
|
|
|
in += 2;
|
2015-02-12 11:18:19 +00:00
|
|
|
// Skip text between \pN and \p0 tags. A \p without a number
|
|
|
|
// is the same as \p0, and leading 0s are also allowed.
|
|
|
|
in_drawing = false;
|
|
|
|
while (in[0] >= '0' && in[0] <= '9') {
|
|
|
|
if (in[0] != '0')
|
|
|
|
in_drawing = true;
|
|
|
|
in += 1;
|
2013-04-28 19:12:11 +00:00
|
|
|
}
|
|
|
|
} else {
|
|
|
|
in += 1;
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
if (in[0] == '\\' && (in[1] == 'N' || in[1] == 'n')) {
|
|
|
|
in += 2;
|
|
|
|
append(b, '\n');
|
|
|
|
} else if (in[0] == '\\' && in[1] == 'h') {
|
|
|
|
in += 2;
|
|
|
|
append(b, ' ');
|
|
|
|
} else if (in[0] == '{') {
|
2015-02-12 11:18:19 +00:00
|
|
|
open_tag_pos = in;
|
2013-04-28 19:12:11 +00:00
|
|
|
in += 1;
|
|
|
|
in_tag = true;
|
|
|
|
} else {
|
|
|
|
if (!in_drawing)
|
|
|
|
append(b, in[0]);
|
|
|
|
in += 1;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
2015-02-12 11:18:19 +00:00
|
|
|
// A '{' without a closing '}' is always visible.
|
|
|
|
if (in_tag) {
|
|
|
|
while (*open_tag_pos)
|
|
|
|
append(b, *open_tag_pos++);
|
|
|
|
}
|
2013-04-28 19:12:11 +00:00
|
|
|
}
|
|
|
|
|
2013-06-02 17:11:25 +00:00
|
|
|
// Empty string counts as whitespace. Reads s[len-1] even if there are \0s.
|
|
|
|
static bool is_whitespace_only(char *s, int len)
|
|
|
|
{
|
|
|
|
for (int n = 0; n < len; n++) {
|
|
|
|
if (s[n] != ' ' && s[n] != '\t')
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
2013-06-01 17:44:12 +00:00
|
|
|
static char *get_text(struct sd *sd, double pts)
|
2013-04-28 19:12:11 +00:00
|
|
|
{
|
2013-06-01 17:44:12 +00:00
|
|
|
struct sd_ass_priv *ctx = sd->priv;
|
2013-04-28 19:12:11 +00:00
|
|
|
ASS_Track *track = ctx->ass_track;
|
|
|
|
|
|
|
|
if (pts == MP_NOPTS_VALUE)
|
|
|
|
return NULL;
|
2015-12-05 22:56:07 +00:00
|
|
|
long long ipts = find_timestamp(sd, pts);
|
2013-04-28 19:12:11 +00:00
|
|
|
|
|
|
|
struct buf b = {ctx->last_text, sizeof(ctx->last_text) - 1};
|
|
|
|
|
|
|
|
for (int i = 0; i < track->n_events; ++i) {
|
|
|
|
ASS_Event *event = track->events + i;
|
2013-06-29 17:39:41 +00:00
|
|
|
if (ipts >= event->Start && ipts < event->Start + event->Duration) {
|
2013-04-28 19:12:11 +00:00
|
|
|
if (event->Text) {
|
2013-06-02 17:11:25 +00:00
|
|
|
int start = b.len;
|
2013-04-28 19:12:11 +00:00
|
|
|
ass_to_plaintext(&b, event->Text);
|
2013-06-23 20:10:38 +00:00
|
|
|
if (is_whitespace_only(&b.start[start], b.len - start)) {
|
|
|
|
b.len = start;
|
|
|
|
} else {
|
2013-06-02 17:11:25 +00:00
|
|
|
append(&b, '\n');
|
2013-06-23 20:10:38 +00:00
|
|
|
}
|
2013-04-28 19:12:11 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
b.start[b.len] = '\0';
|
|
|
|
|
|
|
|
if (b.len > 0 && b.start[b.len - 1] == '\n')
|
|
|
|
b.start[b.len - 1] = '\0';
|
|
|
|
|
|
|
|
return ctx->last_text;
|
|
|
|
}
|
|
|
|
|
2015-11-17 00:54:02 +00:00
|
|
|
static void fill_plaintext(struct sd *sd, double pts)
|
|
|
|
{
|
|
|
|
struct sd_ass_priv *ctx = sd->priv;
|
|
|
|
ASS_Track *track = ctx->shadow_track;
|
|
|
|
|
|
|
|
ass_flush_events(track);
|
|
|
|
|
|
|
|
char *text = get_text(sd, pts);
|
|
|
|
if (!text)
|
|
|
|
return;
|
|
|
|
|
|
|
|
bstr dst = {0};
|
2016-09-24 23:03:59 +00:00
|
|
|
|
|
|
|
if (ctx->on_top)
|
|
|
|
bstr_xappend(NULL, &dst, bstr0("{\\a6}"));
|
|
|
|
|
2015-11-17 00:54:02 +00:00
|
|
|
while (*text) {
|
|
|
|
if (*text == '{')
|
|
|
|
bstr_xappend(NULL, &dst, bstr0("\\"));
|
|
|
|
bstr_xappend(NULL, &dst, (bstr){text, 1});
|
|
|
|
// Break ASS escapes with U+2060 WORD JOINER
|
|
|
|
if (*text == '\\')
|
|
|
|
mp_append_utf8_bstr(NULL, &dst, 0x2060);
|
|
|
|
text++;
|
|
|
|
}
|
|
|
|
|
2016-01-04 14:29:29 +00:00
|
|
|
if (!dst.start)
|
2015-11-17 00:54:02 +00:00
|
|
|
return;
|
|
|
|
|
|
|
|
int n = ass_alloc_event(track);
|
|
|
|
ASS_Event *event = track->events + n;
|
|
|
|
event->Start = 0;
|
|
|
|
event->Duration = INT_MAX;
|
|
|
|
event->Style = track->default_style;
|
|
|
|
event->Text = strdup(dst.start);
|
|
|
|
|
2016-01-04 14:29:29 +00:00
|
|
|
talloc_free(dst.start);
|
2015-11-17 00:54:02 +00:00
|
|
|
}
|
|
|
|
|
2013-06-01 17:44:12 +00:00
|
|
|
static void reset(struct sd *sd)
|
2011-01-18 13:33:36 +00:00
|
|
|
{
|
2013-06-01 17:44:12 +00:00
|
|
|
struct sd_ass_priv *ctx = sd->priv;
|
2016-03-05 11:45:54 +00:00
|
|
|
if (sd->opts->sub_clear_on_seek || ctx->duration_unknown) {
|
2015-12-26 17:32:27 +00:00
|
|
|
ass_flush_events(ctx->ass_track);
|
|
|
|
ctx->num_seen_packets = 0;
|
sub: make preloading more robust
Subtitles can be preloaded, which means they're fully read and copied
into ASS_Track. This in turn is mainly for the sake of being able to do
subtitle seeking (when it comes down to it, subtitle seeking is the
cause for most trouble here).
Commit a714f8e92 broke preloaded subtitles which have events with
unknown duration, such as some MicroDVD samples. The event list gets
cleared on every seek, so the property of being preloaded obviously gets
lost.
Fix this by moving most of the preloading logic to dec_sub.c. If the
subtitle list gets cleared, they are not considered preloaded anymore,
and the logic for demuxed subtitles is used.
As another minor thing, preloadeding subtitles did neither disable the
demux stream, nor did it discard packets. Thus you could get queue
overflows in theory (harmless, but annoying). Fix this by explicitly
discarding packets in preloaded mode.
In summary, now the only difference between preloaded and normal
demuxing are:
1. a seek is issued, and all packets are read on start
2. during playback, discard the packets instead of feeding them to the
subtitle decoder
This is still petty annoying. It would be nice if maintaining the
subtitle index (and maybe a subtitle packet cache for instant subtitle
presentation when seeking back) could be maintained in the demuxer
instead. Half of all file formats with interleaved subtitles have
this anyway (mp4, mkv muxed with newer mkvmerge).
2016-03-06 13:50:36 +00:00
|
|
|
sd->preload_ok = false;
|
2015-12-26 17:32:27 +00:00
|
|
|
}
|
2015-12-18 00:54:14 +00:00
|
|
|
if (ctx->converter)
|
|
|
|
lavc_conv_reset(ctx->converter);
|
2011-01-16 18:03:08 +00:00
|
|
|
}
|
|
|
|
|
2013-06-01 17:44:12 +00:00
|
|
|
static void uninit(struct sd *sd)
|
2011-01-16 18:03:08 +00:00
|
|
|
{
|
2013-06-01 17:44:12 +00:00
|
|
|
struct sd_ass_priv *ctx = sd->priv;
|
2011-01-16 18:03:08 +00:00
|
|
|
|
2015-12-18 00:54:14 +00:00
|
|
|
if (ctx->converter)
|
|
|
|
lavc_conv_uninit(ctx->converter);
|
2014-03-15 21:17:51 +00:00
|
|
|
ass_free_track(ctx->ass_track);
|
2016-01-04 14:29:29 +00:00
|
|
|
ass_free_track(ctx->shadow_track);
|
2015-12-26 17:35:36 +00:00
|
|
|
enable_output(sd, false);
|
2015-12-26 17:34:18 +00:00
|
|
|
ass_library_done(ctx->ass_library);
|
2011-01-16 18:03:08 +00:00
|
|
|
}
|
|
|
|
|
2013-06-28 23:34:11 +00:00
|
|
|
static int control(struct sd *sd, enum sd_ctrl cmd, void *arg)
|
|
|
|
{
|
|
|
|
struct sd_ass_priv *ctx = sd->priv;
|
|
|
|
switch (cmd) {
|
|
|
|
case SD_CTRL_SUB_STEP: {
|
|
|
|
double *a = arg;
|
2015-12-05 22:56:28 +00:00
|
|
|
long long ts = llrint(a[0] * (1000.0 / ctx->sub_speed));
|
|
|
|
long long res = ass_step_sub(ctx->ass_track, ts, a[1]);
|
2013-10-07 15:16:03 +00:00
|
|
|
if (!res)
|
|
|
|
return false;
|
2015-12-05 22:56:28 +00:00
|
|
|
a[0] = res / (1000.0 / ctx->sub_speed);
|
2013-10-07 15:16:03 +00:00
|
|
|
return true;
|
2015-11-17 00:54:02 +00:00
|
|
|
}
|
2013-07-14 23:48:25 +00:00
|
|
|
case SD_CTRL_SET_VIDEO_PARAMS:
|
|
|
|
ctx->video_params = *(struct mp_image_params *)arg;
|
|
|
|
return CONTROL_OK;
|
2015-11-17 00:54:02 +00:00
|
|
|
case SD_CTRL_SET_TOP:
|
|
|
|
ctx->on_top = *(bool *)arg;
|
|
|
|
return CONTROL_OK;
|
2015-12-27 00:25:32 +00:00
|
|
|
case SD_CTRL_SET_VIDEO_DEF_FPS:
|
|
|
|
ctx->video_fps = *(double *)arg;
|
|
|
|
update_subtitle_speed(sd);
|
|
|
|
return CONTROL_OK;
|
2016-09-13 01:15:14 +00:00
|
|
|
case SD_CTRL_UPDATE_SPEED:
|
|
|
|
update_subtitle_speed(sd);
|
|
|
|
return CONTROL_OK;
|
2013-06-28 23:34:11 +00:00
|
|
|
default:
|
|
|
|
return CONTROL_UNKNOWN;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2011-01-16 18:03:08 +00:00
|
|
|
const struct sd_functions sd_ass = {
|
2013-06-03 19:49:39 +00:00
|
|
|
.name = "ass",
|
2013-04-28 19:12:11 +00:00
|
|
|
.accept_packets_in_advance = true,
|
2011-01-16 18:03:08 +00:00
|
|
|
.init = init,
|
|
|
|
.decode = decode,
|
2012-08-25 18:22:39 +00:00
|
|
|
.get_bitmaps = get_bitmaps,
|
2013-04-28 19:12:11 +00:00
|
|
|
.get_text = get_text,
|
2013-06-28 23:34:11 +00:00
|
|
|
.control = control,
|
2011-01-18 13:33:36 +00:00
|
|
|
.reset = reset,
|
2015-12-26 17:35:36 +00:00
|
|
|
.select = enable_output,
|
2011-01-16 18:03:08 +00:00
|
|
|
.uninit = uninit,
|
|
|
|
};
|
2013-07-14 23:48:25 +00:00
|
|
|
|
|
|
|
// Disgusting hack for (xy-)vsfilter color compatibility.
|
|
|
|
static void mangle_colors(struct sd *sd, struct sub_bitmaps *parts)
|
|
|
|
{
|
|
|
|
struct MPOpts *opts = sd->opts;
|
|
|
|
struct sd_ass_priv *ctx = sd->priv;
|
|
|
|
enum mp_csp csp = 0;
|
|
|
|
enum mp_csp_levels levels = 0;
|
|
|
|
if (opts->ass_vsfilter_color_compat == 0) // "no"
|
|
|
|
return;
|
|
|
|
bool force_601 = opts->ass_vsfilter_color_compat == 3;
|
2013-07-20 09:47:41 +00:00
|
|
|
ASS_Track *track = ctx->ass_track;
|
2013-07-14 23:48:25 +00:00
|
|
|
static const int ass_csp[] = {
|
|
|
|
[YCBCR_BT601_TV] = MP_CSP_BT_601,
|
|
|
|
[YCBCR_BT601_PC] = MP_CSP_BT_601,
|
|
|
|
[YCBCR_BT709_TV] = MP_CSP_BT_709,
|
|
|
|
[YCBCR_BT709_PC] = MP_CSP_BT_709,
|
|
|
|
[YCBCR_SMPTE240M_TV] = MP_CSP_SMPTE_240M,
|
|
|
|
[YCBCR_SMPTE240M_PC] = MP_CSP_SMPTE_240M,
|
|
|
|
};
|
|
|
|
static const int ass_levels[] = {
|
|
|
|
[YCBCR_BT601_TV] = MP_CSP_LEVELS_TV,
|
|
|
|
[YCBCR_BT601_PC] = MP_CSP_LEVELS_PC,
|
|
|
|
[YCBCR_BT709_TV] = MP_CSP_LEVELS_TV,
|
|
|
|
[YCBCR_BT709_PC] = MP_CSP_LEVELS_PC,
|
|
|
|
[YCBCR_SMPTE240M_TV] = MP_CSP_LEVELS_TV,
|
|
|
|
[YCBCR_SMPTE240M_PC] = MP_CSP_LEVELS_PC,
|
|
|
|
};
|
|
|
|
int trackcsp = track->YCbCrMatrix;
|
|
|
|
if (force_601)
|
|
|
|
trackcsp = YCBCR_BT601_TV;
|
|
|
|
// NONE is a bit random, but the intention is: don't modify colors.
|
|
|
|
if (trackcsp == YCBCR_NONE)
|
|
|
|
return;
|
|
|
|
if (trackcsp < sizeof(ass_csp) / sizeof(ass_csp[0]))
|
|
|
|
csp = ass_csp[trackcsp];
|
|
|
|
if (trackcsp < sizeof(ass_levels) / sizeof(ass_levels[0]))
|
|
|
|
levels = ass_levels[trackcsp];
|
|
|
|
if (trackcsp == YCBCR_DEFAULT) {
|
|
|
|
csp = MP_CSP_BT_601;
|
|
|
|
levels = MP_CSP_LEVELS_TV;
|
|
|
|
}
|
|
|
|
// Unknown colorspace (either YCBCR_UNKNOWN, or a valid value unknown to us)
|
|
|
|
if (!csp || !levels)
|
|
|
|
return;
|
|
|
|
|
|
|
|
struct mp_image_params params = ctx->video_params;
|
|
|
|
|
|
|
|
if (force_601) {
|
2016-06-29 07:16:13 +00:00
|
|
|
params.color = (struct mp_colorspace){
|
|
|
|
.space = MP_CSP_BT_709,
|
|
|
|
.levels = MP_CSP_LEVELS_TV,
|
|
|
|
};
|
2013-07-14 23:48:25 +00:00
|
|
|
}
|
|
|
|
|
2016-06-29 07:16:13 +00:00
|
|
|
if (csp == params.color.space && levels == params.color.levels)
|
2013-07-14 23:48:25 +00:00
|
|
|
return;
|
|
|
|
|
2016-06-29 07:16:13 +00:00
|
|
|
bool basic_conv = params.color.space == MP_CSP_BT_709 &&
|
|
|
|
params.color.levels == MP_CSP_LEVELS_TV &&
|
2013-07-14 23:48:25 +00:00
|
|
|
csp == MP_CSP_BT_601 &&
|
|
|
|
levels == MP_CSP_LEVELS_TV;
|
|
|
|
|
|
|
|
// With "basic", only do as much as needed for basic compatibility.
|
|
|
|
if (opts->ass_vsfilter_color_compat == 1 && !basic_conv)
|
|
|
|
return;
|
|
|
|
|
2016-06-29 07:16:13 +00:00
|
|
|
if (params.color.space != ctx->last_params.color.space ||
|
|
|
|
params.color.levels != ctx->last_params.color.levels)
|
2013-07-14 23:48:25 +00:00
|
|
|
{
|
|
|
|
int msgl = basic_conv ? MSGL_V : MSGL_WARN;
|
|
|
|
ctx->last_params = params;
|
2013-12-21 18:06:37 +00:00
|
|
|
MP_MSG(sd, msgl, "mangling colors like vsfilter: "
|
2015-03-30 21:52:28 +00:00
|
|
|
"RGB -> %s %s -> %s %s -> RGB\n",
|
|
|
|
m_opt_choice_str(mp_csp_names, csp),
|
|
|
|
m_opt_choice_str(mp_csp_levels_names, levels),
|
2016-06-29 07:16:13 +00:00
|
|
|
m_opt_choice_str(mp_csp_names, params.color.space),
|
|
|
|
m_opt_choice_str(mp_csp_names, params.color.levels));
|
2013-07-14 23:48:25 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
// Conversion that VSFilter would use
|
|
|
|
struct mp_csp_params vs_params = MP_CSP_PARAMS_DEFAULTS;
|
2016-06-29 07:16:13 +00:00
|
|
|
vs_params.color.space = csp;
|
|
|
|
vs_params.color.levels = levels;
|
2015-01-06 15:49:53 +00:00
|
|
|
struct mp_cmat vs_yuv2rgb, vs_rgb2yuv;
|
2015-12-08 23:22:12 +00:00
|
|
|
mp_get_csp_matrix(&vs_params, &vs_yuv2rgb);
|
|
|
|
mp_invert_cmat(&vs_rgb2yuv, &vs_yuv2rgb);
|
2013-07-14 23:48:25 +00:00
|
|
|
|
|
|
|
// Proper conversion to RGB
|
|
|
|
struct mp_csp_params rgb_params = MP_CSP_PARAMS_DEFAULTS;
|
2016-06-29 07:16:13 +00:00
|
|
|
rgb_params.color = params.color;
|
2015-01-06 15:49:53 +00:00
|
|
|
struct mp_cmat vs2rgb;
|
2015-12-08 23:22:12 +00:00
|
|
|
mp_get_csp_matrix(&rgb_params, &vs2rgb);
|
2013-07-14 23:48:25 +00:00
|
|
|
|
|
|
|
for (int n = 0; n < parts->num_parts; n++) {
|
|
|
|
struct sub_bitmap *sb = &parts->parts[n];
|
|
|
|
uint32_t color = sb->libass.color;
|
|
|
|
int r = (color >> 24u) & 0xff;
|
|
|
|
int g = (color >> 16u) & 0xff;
|
|
|
|
int b = (color >> 8u) & 0xff;
|
2014-05-10 08:38:47 +00:00
|
|
|
int a = 0xff - (color & 0xff);
|
2015-12-08 23:08:00 +00:00
|
|
|
int rgb[3] = {r, g, b}, yuv[3];
|
|
|
|
mp_map_fixp_color(&vs_rgb2yuv, 8, rgb, 8, yuv);
|
|
|
|
mp_map_fixp_color(&vs2rgb, 8, yuv, 8, rgb);
|
|
|
|
sb->libass.color = MP_ASS_RGBA(rgb[0], rgb[1], rgb[2], a);
|
2013-07-14 23:48:25 +00:00
|
|
|
}
|
|
|
|
}
|