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
|
|
|
*
|
sd_ass: change license to LGPL
All contributors of the code used for sd_ass.c agreed to the LGPL
relicensing. Some code has a very chaotic history, due to MPlayer
subtitle handling being awful, chaotic, and having been refactored a
dozen of times. Most of the subtitle code was actually rewritten from
scratch (a few times), and the initial sd_ass.c was pretty tiny. So we
should be fine, but it's still a good idea to look at this closely.
Potentially problematic cases of old code leaking into sd_ass.c are
mentioned below.
Some code originates from demux_mkv. Most of this was added by eugeni,
and later moved into mplayer.c or mpcommon.c. The old demux_mkv ASS/SSA
subtitle code is somewhat dangerous from a legal perspective, because it
involves 2 patches by a certain Tristan/z80, who disagreed with LGPL,
and who told us to "rewrite" parts we need. These patches were for
converting the ASS packet data to the old MPlayer text subtitle data
structures. None of that survived in the current code base.
Moving the subtitle handling out of demux_mkv happened in the following
commits: bdb6a07d2a712c, de73d4dd978cb2, 61e4a801913f76. The code by
z80 was removed in b44202b69fc4a1.
At this time, the z80 code was located in mplayer.c and subreader.c.
The code was fully removed, being unnecessary due to the entire old
subtitle rendering code being removed. This adds a ass_to_plaintext(),
function, which replaces the old ASS tag stripping code in
sub_add_text(), which was based on the z80 code. The new function was
intended to strip ASS tags in a correct way, instead of somehow
dealing with other subtitle types (like HTML-style SRT tags), so it
was written from scratch.
Another potential issue is the --sub-fix-timing option is based on
-overlapsub added in d459e644632cb9b. But the implementation is new, and
no code from that commit is used in sd_ass.c. The new implementation
started out in 64b1374a4456435. (The following commit, bd45eb468ced22
removes the original code that was replaced.) The code was later
moved into sd_ass.c.
The --sub-fps option has a similar history.
2017-04-20 08:52:57 +00:00
|
|
|
* mpv 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.
|
2011-01-16 18:03:08 +00:00
|
|
|
*
|
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
|
sd_ass: change license to LGPL
All contributors of the code used for sd_ass.c agreed to the LGPL
relicensing. Some code has a very chaotic history, due to MPlayer
subtitle handling being awful, chaotic, and having been refactored a
dozen of times. Most of the subtitle code was actually rewritten from
scratch (a few times), and the initial sd_ass.c was pretty tiny. So we
should be fine, but it's still a good idea to look at this closely.
Potentially problematic cases of old code leaking into sd_ass.c are
mentioned below.
Some code originates from demux_mkv. Most of this was added by eugeni,
and later moved into mplayer.c or mpcommon.c. The old demux_mkv ASS/SSA
subtitle code is somewhat dangerous from a legal perspective, because it
involves 2 patches by a certain Tristan/z80, who disagreed with LGPL,
and who told us to "rewrite" parts we need. These patches were for
converting the ASS packet data to the old MPlayer text subtitle data
structures. None of that survived in the current code base.
Moving the subtitle handling out of demux_mkv happened in the following
commits: bdb6a07d2a712c, de73d4dd978cb2, 61e4a801913f76. The code by
z80 was removed in b44202b69fc4a1.
At this time, the z80 code was located in mplayer.c and subreader.c.
The code was fully removed, being unnecessary due to the entire old
subtitle rendering code being removed. This adds a ass_to_plaintext(),
function, which replaces the old ASS tag stripping code in
sub_add_text(), which was based on the z80 code. The new function was
intended to strip ASS tags in a correct way, instead of somehow
dealing with other subtitle types (like HTML-style SRT tags), so it
was written from scratch.
Another potential issue is the --sub-fix-timing option is based on
-overlapsub added in d459e644632cb9b. But the implementation is new, and
no code from that commit is used in sd_ass.c. The new implementation
started out in 64b1374a4456435. (The following commit, bd45eb468ced22
removes the original code that was replaced.) The code was later
moved into sd_ass.c.
The --sub-fps option has a similar history.
2017-04-20 08:52:57 +00:00
|
|
|
* GNU Lesser General Public License for more details.
|
2011-01-16 18:03:08 +00:00
|
|
|
*
|
sd_ass: change license to LGPL
All contributors of the code used for sd_ass.c agreed to the LGPL
relicensing. Some code has a very chaotic history, due to MPlayer
subtitle handling being awful, chaotic, and having been refactored a
dozen of times. Most of the subtitle code was actually rewritten from
scratch (a few times), and the initial sd_ass.c was pretty tiny. So we
should be fine, but it's still a good idea to look at this closely.
Potentially problematic cases of old code leaking into sd_ass.c are
mentioned below.
Some code originates from demux_mkv. Most of this was added by eugeni,
and later moved into mplayer.c or mpcommon.c. The old demux_mkv ASS/SSA
subtitle code is somewhat dangerous from a legal perspective, because it
involves 2 patches by a certain Tristan/z80, who disagreed with LGPL,
and who told us to "rewrite" parts we need. These patches were for
converting the ASS packet data to the old MPlayer text subtitle data
structures. None of that survived in the current code base.
Moving the subtitle handling out of demux_mkv happened in the following
commits: bdb6a07d2a712c, de73d4dd978cb2, 61e4a801913f76. The code by
z80 was removed in b44202b69fc4a1.
At this time, the z80 code was located in mplayer.c and subreader.c.
The code was fully removed, being unnecessary due to the entire old
subtitle rendering code being removed. This adds a ass_to_plaintext(),
function, which replaces the old ASS tag stripping code in
sub_add_text(), which was based on the z80 code. The new function was
intended to strip ASS tags in a correct way, instead of somehow
dealing with other subtitle types (like HTML-style SRT tags), so it
was written from scratch.
Another potential issue is the --sub-fix-timing option is based on
-overlapsub added in d459e644632cb9b. But the implementation is new, and
no code from that commit is used in sd_ass.c. The new implementation
started out in 64b1374a4456435. (The following commit, bd45eb468ced22
removes the original code that was replaced.) The code was later
moved into sd_ass.c.
The --sub-fps option has a similar history.
2017-04-20 08:52:57 +00:00
|
|
|
* You should have received a copy of the GNU Lesser General Public
|
|
|
|
* License along 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
|
|
|
|
sub: make filter_sdh a "proper" filter, allow runtime changes
Until now, filter_sdh was simply a function that was called by sd_ass
directly (if enabled).
I want to add another filter, so it's time to turn this into a somewhat
more general subtitle filtering infrastructure.
I pondered whether to reuse the audio/video filtering stuff - but better
not. Also, since subtitles are horrible and tend to refuse proper
abstraction, it's still messed into sd_ass, instead of working on the
dec_sub.c level. Actually mpv used to have subtitle "filters" and even
made subtitle converters part of it, but it was fairly horrible, so
don't do that again.
In addition, make runtime changes possible. Since this was supposed to
be a quick hack, I just decided to put all subtitle filter options into
a separate option group (=> simpler change notification), to manually
push the change through the playloop (like it was sort of before for OSD
options), and to recreate the sub filter chain completely in every
change. Should be good enough.
One strangeness is that due to prefetching and such, most subtitle
packets (or those some time ahead) are actually done filtering when we
change, so the user still needs to manually seek to actually refresh
everything. And since subtitle data is usually cached in ASS_Track (for
other terrible but user-friendly reasons), we also must clear the
subtitle data, but of course only on seek, since otherwise all subtitles
would just disappear. What a fucking mess, but such is life. We could
trigger a "refresh seek" to make this more automatic, but I don't feel
like it currently.
This is slightly inefficient (lots of allocations and copying), but I
decided that it doesn't matter. Could matter slightly for crazy ASS
subtitles that render with thousands of events.
Not very well tested. Still seems to work, but I didn't have many test
cases.
2020-02-16 00:02:17 +00:00
|
|
|
#include "config.h"
|
|
|
|
#include "options/m_config.h"
|
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
|
2023-07-15 17:57:31 +00:00
|
|
|
bool ass_configured;
|
2013-07-14 23:48:25 +00:00
|
|
|
bool is_converted;
|
2015-12-18 00:54:14 +00:00
|
|
|
struct lavc_conv *converter;
|
sub: make filter_sdh a "proper" filter, allow runtime changes
Until now, filter_sdh was simply a function that was called by sd_ass
directly (if enabled).
I want to add another filter, so it's time to turn this into a somewhat
more general subtitle filtering infrastructure.
I pondered whether to reuse the audio/video filtering stuff - but better
not. Also, since subtitles are horrible and tend to refuse proper
abstraction, it's still messed into sd_ass, instead of working on the
dec_sub.c level. Actually mpv used to have subtitle "filters" and even
made subtitle converters part of it, but it was fairly horrible, so
don't do that again.
In addition, make runtime changes possible. Since this was supposed to
be a quick hack, I just decided to put all subtitle filter options into
a separate option group (=> simpler change notification), to manually
push the change through the playloop (like it was sort of before for OSD
options), and to recreate the sub filter chain completely in every
change. Should be good enough.
One strangeness is that due to prefetching and such, most subtitle
packets (or those some time ahead) are actually done filtering when we
change, so the user still needs to manually seek to actually refresh
everything. And since subtitle data is usually cached in ASS_Track (for
other terrible but user-friendly reasons), we also must clear the
subtitle data, but of course only on seek, since otherwise all subtitles
would just disappear. What a fucking mess, but such is life. We could
trigger a "refresh seek" to make this more automatic, but I don't feel
like it currently.
This is slightly inefficient (lots of allocations and copying), but I
decided that it doesn't matter. Could matter slightly for crazy ASS
subtitles that render with thousands of events.
Not very well tested. Still seems to work, but I didn't have many test
cases.
2020-02-16 00:02:17 +00:00
|
|
|
struct sd_filter **filters;
|
|
|
|
int num_filters;
|
|
|
|
bool clear_once;
|
2015-11-17 00:54:02 +00:00
|
|
|
bool on_top;
|
2016-06-30 19:38:50 +00:00
|
|
|
struct mp_ass_packer *packer;
|
video: make OSD/subtitle bitmaps refcounted (sort of)
Making OSD/subtitle bitmaps refcounted was planend a longer time ago,
e.g. the sub_bitmaps.packed field (which refcounts the subtitle bitmap
data) was added in 2016. But nothing benefited much from it, because
struct sub_bitmaps was usually stack allocated, and there was this weird
callback stuff through osd_draw().
Make it possible to get actually refcounted subtitle bitmaps on the OSD
API level. For this, we just copy all subtitle data other than the
bitmaps with sub_bitmaps_copy(). At first, I had planned some fancy
refcount shit, but when that was a big mess and hard to debug and just
boiled to emulating malloc(), I made it a full allocation+copy. This
affects mostly the parts array. With crazy ASS subtitles, this parts
array can get pretty big (thousands of elements or more), in which case
the extra alloc/copy could become performance relevant. But then again
this is just pure bullshit, and I see no need to care. In practice, this
extra work most likely gets drowned out by libass murdering a single
core (while mpv is waiting for it) anyway. So fuck it.
I just wanted this so draw_bmp.c requires only a single call to render
everything. VOs also can benefit from this, because the weird callback
shit isn't necessary anymore (simpler code), but I haven't done anything
about it yet. In general I'd hope this will work towards simplifying the
OSD layer, which is prerequisite for making actual further improvements.
I haven't tested some cases such as the "overlay-add" command. Maybe it
crashes now? Who knows, who cares.
In addition, it might be worthwhile to reduce the code duplication
between all the things that output subtitle bitmaps (with repacking,
image allocation, etc.), but that's orthogonal.
2020-04-26 21:34:32 +00:00
|
|
|
struct sub_bitmap_copy_cache *copy_cache;
|
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;
|
2023-07-15 17:57:31 +00:00
|
|
|
struct mp_osd_res osd;
|
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
|
|
|
|
sub: make filter_sdh a "proper" filter, allow runtime changes
Until now, filter_sdh was simply a function that was called by sd_ass
directly (if enabled).
I want to add another filter, so it's time to turn this into a somewhat
more general subtitle filtering infrastructure.
I pondered whether to reuse the audio/video filtering stuff - but better
not. Also, since subtitles are horrible and tend to refuse proper
abstraction, it's still messed into sd_ass, instead of working on the
dec_sub.c level. Actually mpv used to have subtitle "filters" and even
made subtitle converters part of it, but it was fairly horrible, so
don't do that again.
In addition, make runtime changes possible. Since this was supposed to
be a quick hack, I just decided to put all subtitle filter options into
a separate option group (=> simpler change notification), to manually
push the change through the playloop (like it was sort of before for OSD
options), and to recreate the sub filter chain completely in every
change. Should be good enough.
One strangeness is that due to prefetching and such, most subtitle
packets (or those some time ahead) are actually done filtering when we
change, so the user still needs to manually seek to actually refresh
everything. And since subtitle data is usually cached in ASS_Track (for
other terrible but user-friendly reasons), we also must clear the
subtitle data, but of course only on seek, since otherwise all subtitles
would just disappear. What a fucking mess, but such is life. We could
trigger a "refresh seek" to make this more automatic, but I don't feel
like it currently.
This is slightly inefficient (lots of allocations and copying), but I
decided that it doesn't matter. Could matter slightly for crazy ASS
subtitles that render with thousands of events.
Not very well tested. Still seems to work, but I didn't have many test
cases.
2020-02-16 00:02:17 +00:00
|
|
|
static const struct sd_filter_functions *const filters[] = {
|
|
|
|
// Note: list order defines filter order.
|
|
|
|
&sd_filter_sdh,
|
2020-02-16 01:03:36 +00:00
|
|
|
#if HAVE_POSIX
|
|
|
|
&sd_filter_regex,
|
2021-07-23 16:11:23 +00:00
|
|
|
#endif
|
|
|
|
#if HAVE_JAVASCRIPT
|
|
|
|
&sd_filter_jsre,
|
2020-02-16 01:03:36 +00:00
|
|
|
#endif
|
sub: make filter_sdh a "proper" filter, allow runtime changes
Until now, filter_sdh was simply a function that was called by sd_ass
directly (if enabled).
I want to add another filter, so it's time to turn this into a somewhat
more general subtitle filtering infrastructure.
I pondered whether to reuse the audio/video filtering stuff - but better
not. Also, since subtitles are horrible and tend to refuse proper
abstraction, it's still messed into sd_ass, instead of working on the
dec_sub.c level. Actually mpv used to have subtitle "filters" and even
made subtitle converters part of it, but it was fairly horrible, so
don't do that again.
In addition, make runtime changes possible. Since this was supposed to
be a quick hack, I just decided to put all subtitle filter options into
a separate option group (=> simpler change notification), to manually
push the change through the playloop (like it was sort of before for OSD
options), and to recreate the sub filter chain completely in every
change. Should be good enough.
One strangeness is that due to prefetching and such, most subtitle
packets (or those some time ahead) are actually done filtering when we
change, so the user still needs to manually seek to actually refresh
everything. And since subtitle data is usually cached in ASS_Track (for
other terrible but user-friendly reasons), we also must clear the
subtitle data, but of course only on seek, since otherwise all subtitles
would just disappear. What a fucking mess, but such is life. We could
trigger a "refresh seek" to make this more automatic, but I don't feel
like it currently.
This is slightly inefficient (lots of allocations and copying), but I
decided that it doesn't matter. Could matter slightly for crazy ASS
subtitles that render with thousands of events.
Not very well tested. Still seems to work, but I didn't have many test
cases.
2020-02-16 00:02:17 +00:00
|
|
|
NULL,
|
|
|
|
};
|
|
|
|
|
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.
|
2017-12-29 16:19:25 +00:00
|
|
|
static void mp_ass_add_default_styles(ASS_Track *track, struct mp_subtitle_opts *opts)
|
2015-11-29 12:53:55 +00:00
|
|
|
{
|
|
|
|
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) {
|
2023-09-20 11:41:37 +00:00
|
|
|
track->PlayResX = MP_ASS_FONT_PLAYRESX;
|
2015-11-29 12:53:55 +00:00
|
|
|
track->PlayResY = MP_ASS_FONT_PLAYRESY;
|
|
|
|
}
|
|
|
|
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
|
2020-08-13 12:45:15 +00:00
|
|
|
"application/font-sfnt",
|
2017-12-13 02:19:51 +00:00
|
|
|
"font/collection",
|
|
|
|
"font/otf",
|
|
|
|
"font/sfnt",
|
|
|
|
"font/ttf",
|
2015-12-26 17:34:18 +00:00
|
|
|
NULL
|
|
|
|
};
|
|
|
|
|
2017-12-13 02:24:41 +00:00
|
|
|
static const char *const font_exts[] = {".ttf", ".ttc", ".otf", ".otc", NULL};
|
2015-12-26 17:34:18 +00:00
|
|
|
|
|
|
|
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;
|
2017-12-29 16:19:25 +00:00
|
|
|
struct mp_subtitle_opts *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);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
sub: make filter_sdh a "proper" filter, allow runtime changes
Until now, filter_sdh was simply a function that was called by sd_ass
directly (if enabled).
I want to add another filter, so it's time to turn this into a somewhat
more general subtitle filtering infrastructure.
I pondered whether to reuse the audio/video filtering stuff - but better
not. Also, since subtitles are horrible and tend to refuse proper
abstraction, it's still messed into sd_ass, instead of working on the
dec_sub.c level. Actually mpv used to have subtitle "filters" and even
made subtitle converters part of it, but it was fairly horrible, so
don't do that again.
In addition, make runtime changes possible. Since this was supposed to
be a quick hack, I just decided to put all subtitle filter options into
a separate option group (=> simpler change notification), to manually
push the change through the playloop (like it was sort of before for OSD
options), and to recreate the sub filter chain completely in every
change. Should be good enough.
One strangeness is that due to prefetching and such, most subtitle
packets (or those some time ahead) are actually done filtering when we
change, so the user still needs to manually seek to actually refresh
everything. And since subtitle data is usually cached in ASS_Track (for
other terrible but user-friendly reasons), we also must clear the
subtitle data, but of course only on seek, since otherwise all subtitles
would just disappear. What a fucking mess, but such is life. We could
trigger a "refresh seek" to make this more automatic, but I don't feel
like it currently.
This is slightly inefficient (lots of allocations and copying), but I
decided that it doesn't matter. Could matter slightly for crazy ASS
subtitles that render with thousands of events.
Not very well tested. Still seems to work, but I didn't have many test
cases.
2020-02-16 00:02:17 +00:00
|
|
|
static void filters_destroy(struct sd *sd)
|
|
|
|
{
|
|
|
|
struct sd_ass_priv *ctx = sd->priv;
|
|
|
|
|
|
|
|
for (int n = 0; n < ctx->num_filters; n++) {
|
|
|
|
struct sd_filter *ft = ctx->filters[n];
|
|
|
|
if (ft->driver->uninit)
|
|
|
|
ft->driver->uninit(ft);
|
|
|
|
talloc_free(ft);
|
|
|
|
}
|
|
|
|
ctx->num_filters = 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void filters_init(struct sd *sd)
|
|
|
|
{
|
|
|
|
struct sd_ass_priv *ctx = sd->priv;
|
|
|
|
|
|
|
|
filters_destroy(sd);
|
|
|
|
|
|
|
|
for (int n = 0; filters[n]; n++) {
|
|
|
|
struct sd_filter *ft = talloc_ptrtype(ctx, ft);
|
|
|
|
*ft = (struct sd_filter){
|
|
|
|
.global = sd->global,
|
|
|
|
.log = sd->log,
|
|
|
|
.opts = mp_get_config_group(ft, sd->global, &mp_sub_filter_opts),
|
|
|
|
.driver = filters[n],
|
|
|
|
.codec = "ass",
|
|
|
|
.event_format = ctx->ass_track->event_format,
|
|
|
|
};
|
|
|
|
if (ft->driver->init(ft)) {
|
|
|
|
MP_TARRAY_APPEND(ctx, ctx->filters, ctx->num_filters, ft);
|
|
|
|
} else {
|
|
|
|
talloc_free(ft);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
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);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2020-08-12 15:28:08 +00:00
|
|
|
static void assobjects_init(struct sd *sd)
|
2011-01-16 18:03:08 +00:00
|
|
|
{
|
2020-08-12 15:28:08 +00:00
|
|
|
struct sd_ass_priv *ctx = sd->priv;
|
2017-12-29 16:19:25 +00:00
|
|
|
struct mp_subtitle_opts *opts = sd->opts;
|
2013-07-14 23:48:25 +00:00
|
|
|
|
2022-02-11 02:36:34 +00:00
|
|
|
ctx->ass_library = mp_ass_init(sd->global, sd->opts->sub_style, sd->log);
|
2017-12-29 16:19:25 +00:00
|
|
|
ass_set_extract_fonts(ctx->ass_library, opts->use_embedded_fonts);
|
2015-12-26 17:34:18 +00:00
|
|
|
|
|
|
|
add_subtitle_fonts(sd);
|
|
|
|
|
|
|
|
if (opts->ass_style_override)
|
2023-10-15 15:28:40 +00:00
|
|
|
ass_set_style_overrides(ctx->ass_library, opts->ass_style_override_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);
|
2019-09-18 18:33:29 +00:00
|
|
|
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);
|
2023-09-20 11:41:37 +00:00
|
|
|
ctx->shadow_track->PlayResX = MP_ASS_FONT_PLAYRESX;
|
|
|
|
ctx->shadow_track->PlayResY = MP_ASS_FONT_PLAYRESY;
|
2015-11-17 00:54:02 +00:00
|
|
|
mp_ass_add_default_styles(ctx->shadow_track, opts);
|
|
|
|
|
2020-08-12 15:28:08 +00:00
|
|
|
char *extradata = sd->codec->extradata;
|
|
|
|
int extradata_size = sd->codec->extradata_size;
|
2020-08-12 17:29:10 +00:00
|
|
|
if (ctx->converter) {
|
|
|
|
extradata = lavc_conv_get_extradata(ctx->converter);
|
|
|
|
extradata_size = extradata ? strlen(extradata) : 0;
|
|
|
|
}
|
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
|
|
|
|
|
2015-12-26 17:35:36 +00:00
|
|
|
enable_output(sd, true);
|
2020-08-12 15:28:08 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
static void assobjects_destroy(struct sd *sd)
|
|
|
|
{
|
|
|
|
struct sd_ass_priv *ctx = sd->priv;
|
|
|
|
|
|
|
|
ass_free_track(ctx->ass_track);
|
|
|
|
ass_free_track(ctx->shadow_track);
|
|
|
|
enable_output(sd, false);
|
|
|
|
ass_library_done(ctx->ass_library);
|
|
|
|
}
|
|
|
|
|
|
|
|
static int init(struct sd *sd)
|
|
|
|
{
|
|
|
|
struct sd_ass_priv *ctx = talloc_zero(sd, struct sd_ass_priv);
|
|
|
|
sd->priv = ctx;
|
|
|
|
|
|
|
|
// Note: accept "null" as alias for "ass", so EDL delay_open subtitle
|
|
|
|
// streams work.
|
|
|
|
if (strcmp(sd->codec->codec, "ass") != 0 &&
|
|
|
|
strcmp(sd->codec->codec, "null") != 0)
|
|
|
|
{
|
|
|
|
ctx->is_converted = true;
|
2023-02-20 21:11:47 +00:00
|
|
|
ctx->converter = lavc_conv_create(sd->log, sd->codec);
|
2020-08-12 15:28:08 +00:00
|
|
|
if (!ctx->converter)
|
|
|
|
return -1;
|
|
|
|
|
|
|
|
if (strcmp(sd->codec->codec, "eia_608") == 0)
|
|
|
|
ctx->duration_unknown = 1;
|
|
|
|
}
|
|
|
|
|
|
|
|
assobjects_init(sd);
|
sub: make filter_sdh a "proper" filter, allow runtime changes
Until now, filter_sdh was simply a function that was called by sd_ass
directly (if enabled).
I want to add another filter, so it's time to turn this into a somewhat
more general subtitle filtering infrastructure.
I pondered whether to reuse the audio/video filtering stuff - but better
not. Also, since subtitles are horrible and tend to refuse proper
abstraction, it's still messed into sd_ass, instead of working on the
dec_sub.c level. Actually mpv used to have subtitle "filters" and even
made subtitle converters part of it, but it was fairly horrible, so
don't do that again.
In addition, make runtime changes possible. Since this was supposed to
be a quick hack, I just decided to put all subtitle filter options into
a separate option group (=> simpler change notification), to manually
push the change through the playloop (like it was sort of before for OSD
options), and to recreate the sub filter chain completely in every
change. Should be good enough.
One strangeness is that due to prefetching and such, most subtitle
packets (or those some time ahead) are actually done filtering when we
change, so the user still needs to manually seek to actually refresh
everything. And since subtitle data is usually cached in ASS_Track (for
other terrible but user-friendly reasons), we also must clear the
subtitle data, but of course only on seek, since otherwise all subtitles
would just disappear. What a fucking mess, but such is life. We could
trigger a "refresh seek" to make this more automatic, but I don't feel
like it currently.
This is slightly inefficient (lots of allocations and copying), but I
decided that it doesn't matter. Could matter slightly for crazy ASS
subtitles that render with thousands of events.
Not very well tested. Still seems to work, but I didn't have many test
cases.
2020-02-16 00:02:17 +00:00
|
|
|
filters_init(sd);
|
2015-12-26 17:35:36 +00:00
|
|
|
|
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: make filter_sdh a "proper" filter, allow runtime changes
Until now, filter_sdh was simply a function that was called by sd_ass
directly (if enabled).
I want to add another filter, so it's time to turn this into a somewhat
more general subtitle filtering infrastructure.
I pondered whether to reuse the audio/video filtering stuff - but better
not. Also, since subtitles are horrible and tend to refuse proper
abstraction, it's still messed into sd_ass, instead of working on the
dec_sub.c level. Actually mpv used to have subtitle "filters" and even
made subtitle converters part of it, but it was fairly horrible, so
don't do that again.
In addition, make runtime changes possible. Since this was supposed to
be a quick hack, I just decided to put all subtitle filter options into
a separate option group (=> simpler change notification), to manually
push the change through the playloop (like it was sort of before for OSD
options), and to recreate the sub filter chain completely in every
change. Should be good enough.
One strangeness is that due to prefetching and such, most subtitle
packets (or those some time ahead) are actually done filtering when we
change, so the user still needs to manually seek to actually refresh
everything. And since subtitle data is usually cached in ASS_Track (for
other terrible but user-friendly reasons), we also must clear the
subtitle data, but of course only on seek, since otherwise all subtitles
would just disappear. What a fucking mess, but such is life. We could
trigger a "refresh seek" to make this more automatic, but I don't feel
like it currently.
This is slightly inefficient (lots of allocations and copying), but I
decided that it doesn't matter. Could matter slightly for crazy ASS
subtitles that render with thousands of events.
Not very well tested. Still seems to work, but I didn't have many test
cases.
2020-02-16 00:02:17 +00:00
|
|
|
// Note: pkt is not necessarily a fully valid refcounted packet.
|
|
|
|
static void filter_and_add(struct sd *sd, struct demux_packet *pkt)
|
|
|
|
{
|
|
|
|
struct sd_ass_priv *ctx = sd->priv;
|
|
|
|
struct demux_packet *orig_pkt = pkt;
|
|
|
|
|
|
|
|
for (int n = 0; n < ctx->num_filters; n++) {
|
|
|
|
struct sd_filter *ft = ctx->filters[n];
|
|
|
|
struct demux_packet *npkt = ft->driver->filter(ft, pkt);
|
|
|
|
if (pkt != npkt && pkt != orig_pkt)
|
|
|
|
talloc_free(pkt);
|
|
|
|
pkt = npkt;
|
|
|
|
if (!pkt)
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
ass_process_chunk(ctx->ass_track, pkt->buffer, pkt->len,
|
|
|
|
llrint(pkt->pts * 1000),
|
|
|
|
llrint(pkt->duration * 1000));
|
|
|
|
|
|
|
|
if (pkt != orig_pkt)
|
|
|
|
talloc_free(pkt);
|
|
|
|
}
|
|
|
|
|
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;
|
2019-09-18 18:29:25 +00:00
|
|
|
|
|
|
|
double sub_pts = 0;
|
|
|
|
double sub_duration = 0;
|
|
|
|
char **r = lavc_conv_decode(ctx->converter, packet, &sub_pts,
|
|
|
|
&sub_duration);
|
|
|
|
if (packet->duration < 0 || sub_duration == UINT32_MAX) {
|
2016-03-04 23:13:30 +00:00
|
|
|
if (!ctx->duration_unknown) {
|
|
|
|
MP_WARN(sd, "Subtitle with unknown duration.\n");
|
|
|
|
ctx->duration_unknown = true;
|
|
|
|
}
|
2019-09-18 18:29:25 +00:00
|
|
|
sub_duration = UNKNOWN_DURATION;
|
2016-03-04 23:13:30 +00:00
|
|
|
}
|
2019-09-18 18:26:05 +00:00
|
|
|
|
2017-02-02 09:53:19 +00:00
|
|
|
for (int n = 0; r && r[n]; n++) {
|
sub: make filter_sdh a "proper" filter, allow runtime changes
Until now, filter_sdh was simply a function that was called by sd_ass
directly (if enabled).
I want to add another filter, so it's time to turn this into a somewhat
more general subtitle filtering infrastructure.
I pondered whether to reuse the audio/video filtering stuff - but better
not. Also, since subtitles are horrible and tend to refuse proper
abstraction, it's still messed into sd_ass, instead of working on the
dec_sub.c level. Actually mpv used to have subtitle "filters" and even
made subtitle converters part of it, but it was fairly horrible, so
don't do that again.
In addition, make runtime changes possible. Since this was supposed to
be a quick hack, I just decided to put all subtitle filter options into
a separate option group (=> simpler change notification), to manually
push the change through the playloop (like it was sort of before for OSD
options), and to recreate the sub filter chain completely in every
change. Should be good enough.
One strangeness is that due to prefetching and such, most subtitle
packets (or those some time ahead) are actually done filtering when we
change, so the user still needs to manually seek to actually refresh
everything. And since subtitle data is usually cached in ASS_Track (for
other terrible but user-friendly reasons), we also must clear the
subtitle data, but of course only on seek, since otherwise all subtitles
would just disappear. What a fucking mess, but such is life. We could
trigger a "refresh seek" to make this more automatic, but I don't feel
like it currently.
This is slightly inefficient (lots of allocations and copying), but I
decided that it doesn't matter. Could matter slightly for crazy ASS
subtitles that render with thousands of events.
Not very well tested. Still seems to work, but I didn't have many test
cases.
2020-02-16 00:02:17 +00:00
|
|
|
struct demux_packet pkt2 = {
|
|
|
|
.pts = sub_pts,
|
|
|
|
.duration = sub_duration,
|
|
|
|
.buffer = r[n],
|
|
|
|
.len = strlen(r[n]),
|
|
|
|
};
|
|
|
|
filter_and_add(sd, &pkt2);
|
2017-02-02 09:53:19 +00:00
|
|
|
}
|
2015-12-22 01:35:15 +00:00
|
|
|
if (ctx->duration_unknown) {
|
2022-09-08 08:45:31 +00:00
|
|
|
for (int n = track->n_events - 2; n >= 0; n--) {
|
2016-03-04 23:13:30 +00:00
|
|
|
if (track->events[n].Duration == UNKNOWN_DURATION * 1000) {
|
2022-09-08 08:45:31 +00:00
|
|
|
if (track->events[n].Start != track->events[n + 1].Start) {
|
|
|
|
track->events[n].Duration = track->events[n + 1].Start -
|
|
|
|
track->events[n].Start;
|
|
|
|
} else {
|
|
|
|
track->events[n].Duration = track->events[n + 1].Duration;
|
|
|
|
}
|
2016-03-04 23:13:30 +00:00
|
|
|
}
|
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.
|
sub: make filter_sdh a "proper" filter, allow runtime changes
Until now, filter_sdh was simply a function that was called by sd_ass
directly (if enabled).
I want to add another filter, so it's time to turn this into a somewhat
more general subtitle filtering infrastructure.
I pondered whether to reuse the audio/video filtering stuff - but better
not. Also, since subtitles are horrible and tend to refuse proper
abstraction, it's still messed into sd_ass, instead of working on the
dec_sub.c level. Actually mpv used to have subtitle "filters" and even
made subtitle converters part of it, but it was fairly horrible, so
don't do that again.
In addition, make runtime changes possible. Since this was supposed to
be a quick hack, I just decided to put all subtitle filter options into
a separate option group (=> simpler change notification), to manually
push the change through the playloop (like it was sort of before for OSD
options), and to recreate the sub filter chain completely in every
change. Should be good enough.
One strangeness is that due to prefetching and such, most subtitle
packets (or those some time ahead) are actually done filtering when we
change, so the user still needs to manually seek to actually refresh
everything. And since subtitle data is usually cached in ASS_Track (for
other terrible but user-friendly reasons), we also must clear the
subtitle data, but of course only on seek, since otherwise all subtitles
would just disappear. What a fucking mess, but such is life. We could
trigger a "refresh seek" to make this more automatic, but I don't feel
like it currently.
This is slightly inefficient (lots of allocations and copying), but I
decided that it doesn't matter. Could matter slightly for crazy ASS
subtitles that render with thousands of events.
Not very well tested. Still seems to work, but I didn't have many test
cases.
2020-02-16 00:02:17 +00:00
|
|
|
filter_and_add(sd, packet);
|
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
|
|
|
{
|
2017-12-29 16:19:25 +00:00
|
|
|
struct mp_subtitle_opts *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;
|
2023-08-10 20:51:44 +00:00
|
|
|
float set_sub_pos = 0.0f;
|
2015-02-24 14:49:26 +00:00
|
|
|
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
|
2017-06-06 20:16:29 +00:00
|
|
|
if (converted || opts->ass_style_override == 3) { // 'force'
|
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) {
|
2023-08-10 20:51:44 +00:00
|
|
|
set_sub_pos = 100.0f - opts->sub_pos;
|
2015-02-24 14:49:26 +00:00
|
|
|
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)
|
2020-08-28 13:59:04 +00:00
|
|
|
set_force_flags |= ASS_OVERRIDE_BIT_STYLE | ASS_OVERRIDE_BIT_SELECTIVE_FONT_SCALE;
|
2017-06-06 20:16:29 +00:00
|
|
|
if (opts->ass_style_override == 4) // 'scale'
|
2020-08-28 13:59:04 +00:00
|
|
|
set_force_flags |= ASS_OVERRIDE_BIT_SELECTIVE_FONT_SCALE;
|
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
|
|
|
#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};
|
2023-09-20 11:41:37 +00:00
|
|
|
mp_ass_set_style(&style, MP_ASS_FONT_PLAYRESY, 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);
|
2022-08-31 13:46:17 +00:00
|
|
|
#if LIBASS_VERSION >= 0x01600010
|
|
|
|
if (converted)
|
|
|
|
ass_track_set_feature(track, ASS_FEATURE_WRAP_UNICODE, 1);
|
|
|
|
#endif
|
sd_ass: fix converted subtitles having too-wide borders
Libass commit f08f8ea5 (between 0.16 and 0.17) changed how PlayResX
affects some aspects of rendering.
The libass change fixes a VSFilter compatibility issue which existed
for about two decades, and there are no libass plans to support the
previous behavior, so ultimately we have to adjust the mpv code, and
we can't guarantee to restore the old behavior in all cases.
Starting at this commit, vector drawing coords, font spacing, border
and shadow widths are all affected by PlayResX (specifically, by
the aspect), while previously they were unaffected by PlayResX.
This changed converted sub border and shadow widths in mpv, because
ffmpeg generates the ass with fixed PlayResX of 384 (aspect of 4:3),
and with libass 0.17, if this doesn't match the display aspect, then
borders and shadow were too wide - because most clips aspect is more
than 4:3.
The fact that ffmpeg uses fixed PlayResX of 384 could be considered
an issue, but for now we have no control over it, and ffmpeg doesn't
have the video resolution when it converts an srt source to ass.
So here we adjust PlayResX accordingly so that border/shadows are
now rendered with correct width.
However, regardless of that commit, changing PlayResX also affects
the margin value, so to compensate, we adjust sub-margins-x too.
According to libass devs, this should cover basic srt-to-ass
conversion by ffmpeg to work correctly with libass 0.17.
However, there could be srt extensions which use more complex ass,
and/or ffmpeg conversion of other sub formats (such as aribb24,
aribcaption and movtext), where more things need adjustments.
As of now we don't know what these are, and so we don't really know
what else might remain broken or get broken.
2023-06-25 00:40:25 +00:00
|
|
|
if (converted) {
|
|
|
|
bool override_playres = true;
|
2023-10-15 15:28:40 +00:00
|
|
|
char **ass_style_override_list = opts->ass_style_override_list;
|
|
|
|
for (int i = 0; ass_style_override_list && ass_style_override_list[i]; i++) {
|
|
|
|
if (bstr_find0(bstr0(ass_style_override_list[i]), "PlayResX") >= 0)
|
sd_ass: fix converted subtitles having too-wide borders
Libass commit f08f8ea5 (between 0.16 and 0.17) changed how PlayResX
affects some aspects of rendering.
The libass change fixes a VSFilter compatibility issue which existed
for about two decades, and there are no libass plans to support the
previous behavior, so ultimately we have to adjust the mpv code, and
we can't guarantee to restore the old behavior in all cases.
Starting at this commit, vector drawing coords, font spacing, border
and shadow widths are all affected by PlayResX (specifically, by
the aspect), while previously they were unaffected by PlayResX.
This changed converted sub border and shadow widths in mpv, because
ffmpeg generates the ass with fixed PlayResX of 384 (aspect of 4:3),
and with libass 0.17, if this doesn't match the display aspect, then
borders and shadow were too wide - because most clips aspect is more
than 4:3.
The fact that ffmpeg uses fixed PlayResX of 384 could be considered
an issue, but for now we have no control over it, and ffmpeg doesn't
have the video resolution when it converts an srt source to ass.
So here we adjust PlayResX accordingly so that border/shadows are
now rendered with correct width.
However, regardless of that commit, changing PlayResX also affects
the margin value, so to compensate, we adjust sub-margins-x too.
According to libass devs, this should cover basic srt-to-ass
conversion by ffmpeg to work correctly with libass 0.17.
However, there could be srt extensions which use more complex ass,
and/or ffmpeg conversion of other sub formats (such as aribb24,
aribcaption and movtext), where more things need adjustments.
As of now we don't know what these are, and so we don't really know
what else might remain broken or get broken.
2023-06-25 00:40:25 +00:00
|
|
|
override_playres = false;
|
|
|
|
}
|
|
|
|
|
|
|
|
// srt to ass conversion from ffmpeg has fixed PlayResX of 384 with an
|
|
|
|
// aspect of 4:3. Starting with libass f08f8ea5 (pre 0.17) PlayResX
|
|
|
|
// affects shadow and border widths, among others, so to render borders
|
|
|
|
// and shadows correctly, we adjust PlayResX according to the DAR.
|
|
|
|
// But PlayResX also affects margins, so we adjust those too.
|
|
|
|
// This should ensure basic srt-to-ass ffmpeg conversion has correct
|
|
|
|
// borders, but there could be other issues with some srt extensions
|
|
|
|
// and/or different source formats which would be exposed over time.
|
|
|
|
// Make these adjustments only if the user didn't set PlayResX.
|
|
|
|
if (override_playres) {
|
|
|
|
int vidw = dim->w - (dim->ml + dim->mr);
|
|
|
|
int vidh = dim->h - (dim->mt + dim->mb);
|
|
|
|
track->PlayResX = track->PlayResY * (double)vidw / MPMAX(vidh, 1);
|
|
|
|
// ffmpeg and mpv use a default PlayResX of 384 when it is not known,
|
|
|
|
// this comes from VSFilter.
|
2023-09-20 11:41:37 +00:00
|
|
|
double fix_margins = track->PlayResX / (double)MP_ASS_FONT_PLAYRESX;
|
sd_ass: fix converted subtitles having too-wide borders
Libass commit f08f8ea5 (between 0.16 and 0.17) changed how PlayResX
affects some aspects of rendering.
The libass change fixes a VSFilter compatibility issue which existed
for about two decades, and there are no libass plans to support the
previous behavior, so ultimately we have to adjust the mpv code, and
we can't guarantee to restore the old behavior in all cases.
Starting at this commit, vector drawing coords, font spacing, border
and shadow widths are all affected by PlayResX (specifically, by
the aspect), while previously they were unaffected by PlayResX.
This changed converted sub border and shadow widths in mpv, because
ffmpeg generates the ass with fixed PlayResX of 384 (aspect of 4:3),
and with libass 0.17, if this doesn't match the display aspect, then
borders and shadow were too wide - because most clips aspect is more
than 4:3.
The fact that ffmpeg uses fixed PlayResX of 384 could be considered
an issue, but for now we have no control over it, and ffmpeg doesn't
have the video resolution when it converts an srt source to ass.
So here we adjust PlayResX accordingly so that border/shadows are
now rendered with correct width.
However, regardless of that commit, changing PlayResX also affects
the margin value, so to compensate, we adjust sub-margins-x too.
According to libass devs, this should cover basic srt-to-ass
conversion by ffmpeg to work correctly with libass 0.17.
However, there could be srt extensions which use more complex ass,
and/or ffmpeg conversion of other sub formats (such as aribb24,
aribcaption and movtext), where more things need adjustments.
As of now we don't know what these are, and so we don't really know
what else might remain broken or get broken.
2023-06-25 00:40:25 +00:00
|
|
|
track->styles->MarginL = round(track->styles->MarginL * fix_margins);
|
|
|
|
track->styles->MarginR = round(track->styles->MarginR * fix_margins);
|
|
|
|
}
|
|
|
|
}
|
2015-02-24 14:49:26 +00:00
|
|
|
}
|
|
|
|
|
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;
|
|
|
|
|
|
|
|
long long ts = llrint(pts * 1000);
|
|
|
|
|
2023-09-09 02:15:03 +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
|
|
|
|
|
video: make OSD/subtitle bitmaps refcounted (sort of)
Making OSD/subtitle bitmaps refcounted was planend a longer time ago,
e.g. the sub_bitmaps.packed field (which refcounts the subtitle bitmap
data) was added in 2016. But nothing benefited much from it, because
struct sub_bitmaps was usually stack allocated, and there was this weird
callback stuff through osd_draw().
Make it possible to get actually refcounted subtitle bitmaps on the OSD
API level. For this, we just copy all subtitle data other than the
bitmaps with sub_bitmaps_copy(). At first, I had planned some fancy
refcount shit, but when that was a big mess and hard to debug and just
boiled to emulating malloc(), I made it a full allocation+copy. This
affects mostly the parts array. With crazy ASS subtitles, this parts
array can get pretty big (thousands of elements or more), in which case
the extra alloc/copy could become performance relevant. But then again
this is just pure bullshit, and I see no need to care. In practice, this
extra work most likely gets drowned out by libass murdering a single
core (while mpv is waiting for it) anyway. So fuck it.
I just wanted this so draw_bmp.c requires only a single call to render
everything. VOs also can benefit from this, because the weird callback
shit isn't necessary anymore (simpler code), but I haven't done anything
about it yet. In general I'd hope this will work towards simplifying the
OSD layer, which is prerequisite for making actual further improvements.
I haven't tested some cases such as the "overlay-add" command. Maybe it
crashes now? Who knows, who cares.
In addition, it might be worthwhile to reduce the code duplication
between all the things that output subtitle bitmaps (with repacking,
image allocation, etc.), but that's orthogonal.
2020-04-26 21:34:32 +00:00
|
|
|
static struct sub_bitmaps *get_bitmaps(struct sd *sd, struct mp_osd_res dim,
|
|
|
|
int format, double pts)
|
2012-08-25 18:22:39 +00:00
|
|
|
{
|
2013-06-01 17:44:12 +00:00
|
|
|
struct sd_ass_priv *ctx = sd->priv;
|
2017-12-29 16:19:25 +00:00
|
|
|
struct mp_subtitle_opts *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;
|
video: make OSD/subtitle bitmaps refcounted (sort of)
Making OSD/subtitle bitmaps refcounted was planend a longer time ago,
e.g. the sub_bitmaps.packed field (which refcounts the subtitle bitmap
data) was added in 2016. But nothing benefited much from it, because
struct sub_bitmaps was usually stack allocated, and there was this weird
callback stuff through osd_draw().
Make it possible to get actually refcounted subtitle bitmaps on the OSD
API level. For this, we just copy all subtitle data other than the
bitmaps with sub_bitmaps_copy(). At first, I had planned some fancy
refcount shit, but when that was a big mess and hard to debug and just
boiled to emulating malloc(), I made it a full allocation+copy. This
affects mostly the parts array. With crazy ASS subtitles, this parts
array can get pretty big (thousands of elements or more), in which case
the extra alloc/copy could become performance relevant. But then again
this is just pure bullshit, and I see no need to care. In practice, this
extra work most likely gets drowned out by libass murdering a single
core (while mpv is waiting for it) anyway. So fuck it.
I just wanted this so draw_bmp.c requires only a single call to render
everything. VOs also can benefit from this, because the weird callback
shit isn't necessary anymore (simpler code), but I haven't done anything
about it yet. In general I'd hope this will work towards simplifying the
OSD layer, which is prerequisite for making actual further improvements.
I haven't tested some cases such as the "overlay-add" command. Maybe it
crashes now? Who knows, who cares.
In addition, it might be worthwhile to reduce the code duplication
between all the things that output subtitle bitmaps (with repacking,
image allocation, etc.), but that's orthogonal.
2020-04-26 21:34:32 +00:00
|
|
|
struct sub_bitmaps *res = &(struct sub_bitmaps){0};
|
2012-08-25 18:22:39 +00:00
|
|
|
|
2023-07-15 17:57:31 +00:00
|
|
|
// Always update the osd_res
|
|
|
|
struct mp_osd_res old_osd = ctx->osd;
|
|
|
|
ctx->osd = dim;
|
|
|
|
|
2015-12-26 17:35:36 +00:00
|
|
|
if (pts == MP_NOPTS_VALUE || !renderer)
|
video: make OSD/subtitle bitmaps refcounted (sort of)
Making OSD/subtitle bitmaps refcounted was planend a longer time ago,
e.g. the sub_bitmaps.packed field (which refcounts the subtitle bitmap
data) was added in 2016. But nothing benefited much from it, because
struct sub_bitmaps was usually stack allocated, and there was this weird
callback stuff through osd_draw().
Make it possible to get actually refcounted subtitle bitmaps on the OSD
API level. For this, we just copy all subtitle data other than the
bitmaps with sub_bitmaps_copy(). At first, I had planned some fancy
refcount shit, but when that was a big mess and hard to debug and just
boiled to emulating malloc(), I made it a full allocation+copy. This
affects mostly the parts array. With crazy ASS subtitles, this parts
array can get pretty big (thousands of elements or more), in which case
the extra alloc/copy could become performance relevant. But then again
this is just pure bullshit, and I see no need to care. In practice, this
extra work most likely gets drowned out by libass murdering a single
core (while mpv is waiting for it) anyway. So fuck it.
I just wanted this so draw_bmp.c requires only a single call to render
everything. VOs also can benefit from this, because the weird callback
shit isn't necessary anymore (simpler code), but I haven't done anything
about it yet. In general I'd hope this will work towards simplifying the
OSD layer, which is prerequisite for making actual further improvements.
I haven't tested some cases such as the "overlay-add" command. Maybe it
crashes now? Who knows, who cares.
In addition, it might be worthwhile to reduce the code duplication
between all the things that output subtitle bitmaps (with repacking,
image allocation, etc.), but that's orthogonal.
2020-04-26 21:34:32 +00:00
|
|
|
goto done;
|
2012-08-25 18:22:39 +00:00
|
|
|
|
2020-06-22 20:08:42 +00:00
|
|
|
// Currently no supported text sub formats support a distinction between forced
|
|
|
|
// and unforced lines, so we just assume everything's unforced and discard everything.
|
|
|
|
// If we ever see a format that makes this distinction, we can add support here.
|
2023-08-29 01:15:49 +00:00
|
|
|
if (opts->sub_forced_events_only)
|
2020-06-22 20:08:42 +00:00
|
|
|
goto done;
|
|
|
|
|
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
|
|
|
}
|
2023-07-15 17:57:31 +00:00
|
|
|
if (!ctx->ass_configured || !osd_res_equals(old_osd, ctx->osd)) {
|
|
|
|
configure_ass(sd, &dim, converted, track);
|
|
|
|
ctx->ass_configured = true;
|
|
|
|
}
|
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
|
|
|
|
video: make OSD/subtitle bitmaps refcounted (sort of)
Making OSD/subtitle bitmaps refcounted was planend a longer time ago,
e.g. the sub_bitmaps.packed field (which refcounts the subtitle bitmap
data) was added in 2016. But nothing benefited much from it, because
struct sub_bitmaps was usually stack allocated, and there was this weird
callback stuff through osd_draw().
Make it possible to get actually refcounted subtitle bitmaps on the OSD
API level. For this, we just copy all subtitle data other than the
bitmaps with sub_bitmaps_copy(). At first, I had planned some fancy
refcount shit, but when that was a big mess and hard to debug and just
boiled to emulating malloc(), I made it a full allocation+copy. This
affects mostly the parts array. With crazy ASS subtitles, this parts
array can get pretty big (thousands of elements or more), in which case
the extra alloc/copy could become performance relevant. But then again
this is just pure bullshit, and I see no need to care. In practice, this
extra work most likely gets drowned out by libass murdering a single
core (while mpv is waiting for it) anyway. So fuck it.
I just wanted this so draw_bmp.c requires only a single call to render
everything. VOs also can benefit from this, because the weird callback
shit isn't necessary anymore (simpler code), but I haven't done anything
about it yet. In general I'd hope this will work towards simplifying the
OSD layer, which is prerequisite for making actual further improvements.
I haven't tested some cases such as the "overlay-add" command. Maybe it
crashes now? Who knows, who cares.
In addition, it might be worthwhile to reduce the code duplication
between all the things that output subtitle bitmaps (with repacking,
image allocation, etc.), but that's orthogonal.
2020-04-26 21:34:32 +00:00
|
|
|
done:
|
|
|
|
// mangle_colors() modifies the color field, so copy the thing _before_.
|
|
|
|
res = sub_bitmaps_copy(&ctx->copy_cache, res);
|
2016-03-08 19:49:33 +00:00
|
|
|
|
video: make OSD/subtitle bitmaps refcounted (sort of)
Making OSD/subtitle bitmaps refcounted was planend a longer time ago,
e.g. the sub_bitmaps.packed field (which refcounts the subtitle bitmap
data) was added in 2016. But nothing benefited much from it, because
struct sub_bitmaps was usually stack allocated, and there was this weird
callback stuff through osd_draw().
Make it possible to get actually refcounted subtitle bitmaps on the OSD
API level. For this, we just copy all subtitle data other than the
bitmaps with sub_bitmaps_copy(). At first, I had planned some fancy
refcount shit, but when that was a big mess and hard to debug and just
boiled to emulating malloc(), I made it a full allocation+copy. This
affects mostly the parts array. With crazy ASS subtitles, this parts
array can get pretty big (thousands of elements or more), in which case
the extra alloc/copy could become performance relevant. But then again
this is just pure bullshit, and I see no need to care. In practice, this
extra work most likely gets drowned out by libass murdering a single
core (while mpv is waiting for it) anyway. So fuck it.
I just wanted this so draw_bmp.c requires only a single call to render
everything. VOs also can benefit from this, because the weird callback
shit isn't necessary anymore (simpler code), but I haven't done anything
about it yet. In general I'd hope this will work towards simplifying the
OSD layer, which is prerequisite for making actual further improvements.
I haven't tested some cases such as the "overlay-add" command. Maybe it
crashes now? Who knows, who cares.
In addition, it might be worthwhile to reduce the code duplication
between all the things that output subtitle bitmaps (with repacking,
image allocation, etc.), but that's orthogonal.
2020-04-26 21:34:32 +00:00
|
|
|
if (!converted && res)
|
2016-06-30 19:38:50 +00:00
|
|
|
mangle_colors(sd, res);
|
video: make OSD/subtitle bitmaps refcounted (sort of)
Making OSD/subtitle bitmaps refcounted was planend a longer time ago,
e.g. the sub_bitmaps.packed field (which refcounts the subtitle bitmap
data) was added in 2016. But nothing benefited much from it, because
struct sub_bitmaps was usually stack allocated, and there was this weird
callback stuff through osd_draw().
Make it possible to get actually refcounted subtitle bitmaps on the OSD
API level. For this, we just copy all subtitle data other than the
bitmaps with sub_bitmaps_copy(). At first, I had planned some fancy
refcount shit, but when that was a big mess and hard to debug and just
boiled to emulating malloc(), I made it a full allocation+copy. This
affects mostly the parts array. With crazy ASS subtitles, this parts
array can get pretty big (thousands of elements or more), in which case
the extra alloc/copy could become performance relevant. But then again
this is just pure bullshit, and I see no need to care. In practice, this
extra work most likely gets drowned out by libass murdering a single
core (while mpv is waiting for it) anyway. So fuck it.
I just wanted this so draw_bmp.c requires only a single call to render
everything. VOs also can benefit from this, because the weird callback
shit isn't necessary anymore (simpler code), but I haven't done anything
about it yet. In general I'd hope this will work towards simplifying the
OSD layer, which is prerequisite for making actual further improvements.
I haven't tested some cases such as the "overlay-add" command. Maybe it
crashes now? Who knows, who cares.
In addition, it might be worthwhile to reduce the code duplication
between all the things that output subtitle bitmaps (with repacking,
image allocation, etc.), but that's orthogonal.
2020-04-26 21:34:32 +00:00
|
|
|
|
|
|
|
return 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;
|
|
|
|
}
|
|
|
|
|
2020-05-14 20:14:49 +00:00
|
|
|
static char *get_text_buf(struct sd *sd, double pts, enum sd_text_type type)
|
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;
|
2020-05-14 20:14:49 +00:00
|
|
|
if (type == SD_TEXT_TYPE_PLAIN) {
|
|
|
|
ass_to_plaintext(&b, event->Text);
|
|
|
|
} else {
|
|
|
|
char *t = event->Text;
|
|
|
|
while (*t)
|
|
|
|
append(&b, *t++);
|
|
|
|
}
|
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;
|
|
|
|
}
|
|
|
|
|
2020-05-14 20:14:49 +00:00
|
|
|
static char *get_text(struct sd *sd, double pts, enum sd_text_type type)
|
|
|
|
{
|
|
|
|
return talloc_strdup(NULL, get_text_buf(sd, pts, type));
|
|
|
|
}
|
|
|
|
|
2019-09-21 18:11:18 +00:00
|
|
|
static struct sd_times get_times(struct sd *sd, double pts)
|
|
|
|
{
|
|
|
|
struct sd_ass_priv *ctx = sd->priv;
|
|
|
|
ASS_Track *track = ctx->ass_track;
|
|
|
|
struct sd_times res = { .start = MP_NOPTS_VALUE, .end = MP_NOPTS_VALUE };
|
|
|
|
|
2023-10-05 19:05:08 +00:00
|
|
|
if (pts == MP_NOPTS_VALUE)
|
2019-09-21 18:11:18 +00:00
|
|
|
return res;
|
|
|
|
|
|
|
|
long long ipts = find_timestamp(sd, pts);
|
|
|
|
|
|
|
|
for (int i = 0; i < track->n_events; ++i) {
|
|
|
|
ASS_Event *event = track->events + i;
|
|
|
|
if (ipts >= event->Start && ipts < event->Start + event->Duration) {
|
|
|
|
double start = event->Start / 1000.0;
|
|
|
|
double end = event->Duration == UNKNOWN_DURATION ?
|
|
|
|
MP_NOPTS_VALUE : (event->Start + event->Duration) / 1000.0;
|
|
|
|
|
|
|
|
if (res.start == MP_NOPTS_VALUE || res.start > start)
|
|
|
|
res.start = start;
|
|
|
|
|
|
|
|
if (res.end == MP_NOPTS_VALUE || res.end < end)
|
|
|
|
res.end = end;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
return res;
|
|
|
|
}
|
|
|
|
|
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);
|
|
|
|
|
2020-05-14 20:14:49 +00:00
|
|
|
char *text = get_text_buf(sd, pts, SD_TEXT_TYPE_PLAIN);
|
2015-11-17 00:54:02 +00:00
|
|
|
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;
|
sub: make filter_sdh a "proper" filter, allow runtime changes
Until now, filter_sdh was simply a function that was called by sd_ass
directly (if enabled).
I want to add another filter, so it's time to turn this into a somewhat
more general subtitle filtering infrastructure.
I pondered whether to reuse the audio/video filtering stuff - but better
not. Also, since subtitles are horrible and tend to refuse proper
abstraction, it's still messed into sd_ass, instead of working on the
dec_sub.c level. Actually mpv used to have subtitle "filters" and even
made subtitle converters part of it, but it was fairly horrible, so
don't do that again.
In addition, make runtime changes possible. Since this was supposed to
be a quick hack, I just decided to put all subtitle filter options into
a separate option group (=> simpler change notification), to manually
push the change through the playloop (like it was sort of before for OSD
options), and to recreate the sub filter chain completely in every
change. Should be good enough.
One strangeness is that due to prefetching and such, most subtitle
packets (or those some time ahead) are actually done filtering when we
change, so the user still needs to manually seek to actually refresh
everything. And since subtitle data is usually cached in ASS_Track (for
other terrible but user-friendly reasons), we also must clear the
subtitle data, but of course only on seek, since otherwise all subtitles
would just disappear. What a fucking mess, but such is life. We could
trigger a "refresh seek" to make this more automatic, but I don't feel
like it currently.
This is slightly inefficient (lots of allocations and copying), but I
decided that it doesn't matter. Could matter slightly for crazy ASS
subtitles that render with thousands of events.
Not very well tested. Still seems to work, but I didn't have many test
cases.
2020-02-16 00:02:17 +00:00
|
|
|
if (sd->opts->sub_clear_on_seek || ctx->duration_unknown || ctx->clear_once) {
|
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;
|
sub: make filter_sdh a "proper" filter, allow runtime changes
Until now, filter_sdh was simply a function that was called by sd_ass
directly (if enabled).
I want to add another filter, so it's time to turn this into a somewhat
more general subtitle filtering infrastructure.
I pondered whether to reuse the audio/video filtering stuff - but better
not. Also, since subtitles are horrible and tend to refuse proper
abstraction, it's still messed into sd_ass, instead of working on the
dec_sub.c level. Actually mpv used to have subtitle "filters" and even
made subtitle converters part of it, but it was fairly horrible, so
don't do that again.
In addition, make runtime changes possible. Since this was supposed to
be a quick hack, I just decided to put all subtitle filter options into
a separate option group (=> simpler change notification), to manually
push the change through the playloop (like it was sort of before for OSD
options), and to recreate the sub filter chain completely in every
change. Should be good enough.
One strangeness is that due to prefetching and such, most subtitle
packets (or those some time ahead) are actually done filtering when we
change, so the user still needs to manually seek to actually refresh
everything. And since subtitle data is usually cached in ASS_Track (for
other terrible but user-friendly reasons), we also must clear the
subtitle data, but of course only on seek, since otherwise all subtitles
would just disappear. What a fucking mess, but such is life. We could
trigger a "refresh seek" to make this more automatic, but I don't feel
like it currently.
This is slightly inefficient (lots of allocations and copying), but I
decided that it doesn't matter. Could matter slightly for crazy ASS
subtitles that render with thousands of events.
Not very well tested. Still seems to work, but I didn't have many test
cases.
2020-02-16 00:02:17 +00:00
|
|
|
ctx->clear_once = 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
|
|
|
|
sub: make filter_sdh a "proper" filter, allow runtime changes
Until now, filter_sdh was simply a function that was called by sd_ass
directly (if enabled).
I want to add another filter, so it's time to turn this into a somewhat
more general subtitle filtering infrastructure.
I pondered whether to reuse the audio/video filtering stuff - but better
not. Also, since subtitles are horrible and tend to refuse proper
abstraction, it's still messed into sd_ass, instead of working on the
dec_sub.c level. Actually mpv used to have subtitle "filters" and even
made subtitle converters part of it, but it was fairly horrible, so
don't do that again.
In addition, make runtime changes possible. Since this was supposed to
be a quick hack, I just decided to put all subtitle filter options into
a separate option group (=> simpler change notification), to manually
push the change through the playloop (like it was sort of before for OSD
options), and to recreate the sub filter chain completely in every
change. Should be good enough.
One strangeness is that due to prefetching and such, most subtitle
packets (or those some time ahead) are actually done filtering when we
change, so the user still needs to manually seek to actually refresh
everything. And since subtitle data is usually cached in ASS_Track (for
other terrible but user-friendly reasons), we also must clear the
subtitle data, but of course only on seek, since otherwise all subtitles
would just disappear. What a fucking mess, but such is life. We could
trigger a "refresh seek" to make this more automatic, but I don't feel
like it currently.
This is slightly inefficient (lots of allocations and copying), but I
decided that it doesn't matter. Could matter slightly for crazy ASS
subtitles that render with thousands of events.
Not very well tested. Still seems to work, but I didn't have many test
cases.
2020-02-16 00:02:17 +00:00
|
|
|
filters_destroy(sd);
|
2015-12-18 00:54:14 +00:00
|
|
|
if (ctx->converter)
|
|
|
|
lavc_conv_uninit(ctx->converter);
|
2020-08-12 15:28:08 +00:00
|
|
|
assobjects_destroy(sd);
|
video: make OSD/subtitle bitmaps refcounted (sort of)
Making OSD/subtitle bitmaps refcounted was planend a longer time ago,
e.g. the sub_bitmaps.packed field (which refcounts the subtitle bitmap
data) was added in 2016. But nothing benefited much from it, because
struct sub_bitmaps was usually stack allocated, and there was this weird
callback stuff through osd_draw().
Make it possible to get actually refcounted subtitle bitmaps on the OSD
API level. For this, we just copy all subtitle data other than the
bitmaps with sub_bitmaps_copy(). At first, I had planned some fancy
refcount shit, but when that was a big mess and hard to debug and just
boiled to emulating malloc(), I made it a full allocation+copy. This
affects mostly the parts array. With crazy ASS subtitles, this parts
array can get pretty big (thousands of elements or more), in which case
the extra alloc/copy could become performance relevant. But then again
this is just pure bullshit, and I see no need to care. In practice, this
extra work most likely gets drowned out by libass murdering a single
core (while mpv is waiting for it) anyway. So fuck it.
I just wanted this so draw_bmp.c requires only a single call to render
everything. VOs also can benefit from this, because the weird callback
shit isn't necessary anymore (simpler code), but I haven't done anything
about it yet. In general I'd hope this will work towards simplifying the
OSD layer, which is prerequisite for making actual further improvements.
I haven't tested some cases such as the "overlay-add" command. Maybe it
crashes now? Who knows, who cares.
In addition, it might be worthwhile to reduce the code duplication
between all the things that output subtitle bitmaps (with repacking,
image allocation, etc.), but that's orthogonal.
2020-04-26 21:34:32 +00:00
|
|
|
talloc_free(ctx->copy_cache);
|
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;
|
2017-12-29 14:39:38 +00:00
|
|
|
long long ts = llrint(a[0] * 1000.0);
|
2015-12-05 22:56:28 +00:00
|
|
|
long long res = ass_step_sub(ctx->ass_track, ts, a[1]);
|
2013-10-07 15:16:03 +00:00
|
|
|
if (!res)
|
|
|
|
return false;
|
2017-12-29 14:39:38 +00:00
|
|
|
a[0] += res / 1000.0;
|
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;
|
sub: make filter_sdh a "proper" filter, allow runtime changes
Until now, filter_sdh was simply a function that was called by sd_ass
directly (if enabled).
I want to add another filter, so it's time to turn this into a somewhat
more general subtitle filtering infrastructure.
I pondered whether to reuse the audio/video filtering stuff - but better
not. Also, since subtitles are horrible and tend to refuse proper
abstraction, it's still messed into sd_ass, instead of working on the
dec_sub.c level. Actually mpv used to have subtitle "filters" and even
made subtitle converters part of it, but it was fairly horrible, so
don't do that again.
In addition, make runtime changes possible. Since this was supposed to
be a quick hack, I just decided to put all subtitle filter options into
a separate option group (=> simpler change notification), to manually
push the change through the playloop (like it was sort of before for OSD
options), and to recreate the sub filter chain completely in every
change. Should be good enough.
One strangeness is that due to prefetching and such, most subtitle
packets (or those some time ahead) are actually done filtering when we
change, so the user still needs to manually seek to actually refresh
everything. And since subtitle data is usually cached in ASS_Track (for
other terrible but user-friendly reasons), we also must clear the
subtitle data, but of course only on seek, since otherwise all subtitles
would just disappear. What a fucking mess, but such is life. We could
trigger a "refresh seek" to make this more automatic, but I don't feel
like it currently.
This is slightly inefficient (lots of allocations and copying), but I
decided that it doesn't matter. Could matter slightly for crazy ASS
subtitles that render with thousands of events.
Not very well tested. Still seems to work, but I didn't have many test
cases.
2020-02-16 00:02:17 +00:00
|
|
|
case SD_CTRL_UPDATE_OPTS: {
|
|
|
|
int flags = (uintptr_t)arg;
|
|
|
|
if (flags & UPDATE_SUB_FILT) {
|
|
|
|
filters_destroy(sd);
|
|
|
|
filters_init(sd);
|
|
|
|
ctx->clear_once = true; // allow reloading on seeks
|
|
|
|
}
|
2020-08-12 15:28:08 +00:00
|
|
|
if (flags & UPDATE_SUB_HARD) {
|
2023-03-08 18:05:59 +00:00
|
|
|
// ass_track will be recreated, so clear duplicate cache
|
|
|
|
ctx->clear_once = true;
|
|
|
|
reset(sd);
|
|
|
|
|
2020-08-12 15:28:08 +00:00
|
|
|
assobjects_destroy(sd);
|
|
|
|
assobjects_init(sd);
|
|
|
|
}
|
2023-07-15 17:57:31 +00:00
|
|
|
ctx->ass_configured = false; // ass always needs to be reconfigured
|
sub: make filter_sdh a "proper" filter, allow runtime changes
Until now, filter_sdh was simply a function that was called by sd_ass
directly (if enabled).
I want to add another filter, so it's time to turn this into a somewhat
more general subtitle filtering infrastructure.
I pondered whether to reuse the audio/video filtering stuff - but better
not. Also, since subtitles are horrible and tend to refuse proper
abstraction, it's still messed into sd_ass, instead of working on the
dec_sub.c level. Actually mpv used to have subtitle "filters" and even
made subtitle converters part of it, but it was fairly horrible, so
don't do that again.
In addition, make runtime changes possible. Since this was supposed to
be a quick hack, I just decided to put all subtitle filter options into
a separate option group (=> simpler change notification), to manually
push the change through the playloop (like it was sort of before for OSD
options), and to recreate the sub filter chain completely in every
change. Should be good enough.
One strangeness is that due to prefetching and such, most subtitle
packets (or those some time ahead) are actually done filtering when we
change, so the user still needs to manually seek to actually refresh
everything. And since subtitle data is usually cached in ASS_Track (for
other terrible but user-friendly reasons), we also must clear the
subtitle data, but of course only on seek, since otherwise all subtitles
would just disappear. What a fucking mess, but such is life. We could
trigger a "refresh seek" to make this more automatic, but I don't feel
like it currently.
This is slightly inefficient (lots of allocations and copying), but I
decided that it doesn't matter. Could matter slightly for crazy ASS
subtitles that render with thousands of events.
Not very well tested. Still seems to work, but I didn't have many test
cases.
2020-02-16 00:02:17 +00:00
|
|
|
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,
|
2019-09-21 18:11:18 +00:00
|
|
|
.get_times = get_times,
|
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)
|
|
|
|
{
|
2017-12-29 16:19:25 +00:00
|
|
|
struct mp_subtitle_opts *opts = sd->opts;
|
2013-07-14 23:48:25 +00:00
|
|
|
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
|
|
|
}
|
|
|
|
|
2022-11-02 17:16:00 +00:00
|
|
|
if ((csp == params.color.space && levels == params.color.levels) ||
|
|
|
|
params.color.space == MP_CSP_RGB) // Even VSFilter doesn't mangle on RGB video
|
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
|
|
|
}
|
|
|
|
}
|
2021-07-22 17:23:13 +00:00
|
|
|
|
|
|
|
int sd_ass_fmt_offset(const char *evt_fmt)
|
|
|
|
{
|
|
|
|
// "Text" is always last (as it's arbitrary content in buf), e.g. format:
|
|
|
|
// "Layer, Start, End, Style, Name, MarginL, MarginR, MarginV, Effect, Text"
|
|
|
|
int n = 0;
|
|
|
|
while (evt_fmt && (evt_fmt = strchr(evt_fmt, ',')))
|
|
|
|
evt_fmt++, n++;
|
|
|
|
return n-1; // buffer is without the format's Start/End, with ReadOrder
|
|
|
|
}
|
|
|
|
|
|
|
|
bstr sd_ass_pkt_text(struct sd_filter *ft, struct demux_packet *pkt, int offset)
|
|
|
|
{
|
|
|
|
// e.g. pkt->buffer ("4" is ReadOrder): "4,0,Default,,0,0,0,,fifth line"
|
|
|
|
bstr txt = {(char *)pkt->buffer, pkt->len}, t0 = txt;
|
|
|
|
while (offset-- > 0) {
|
|
|
|
int n = bstrchr(txt, ',');
|
|
|
|
if (n < 0) { // shouldn't happen
|
|
|
|
MP_WARN(ft, "Malformed event '%.*s'\n", BSTR_P(t0));
|
|
|
|
return (bstr){NULL, 0};
|
|
|
|
}
|
|
|
|
txt = bstr_cut(txt, n+1);
|
|
|
|
}
|
|
|
|
return txt;
|
|
|
|
}
|
2021-07-23 17:31:15 +00:00
|
|
|
|
|
|
|
bstr sd_ass_to_plaintext(char *out, size_t out_siz, const char *in)
|
|
|
|
{
|
|
|
|
struct buf b = {out, out_siz, 0};
|
|
|
|
ass_to_plaintext(&b, in);
|
|
|
|
if (b.len < out_siz)
|
|
|
|
out[b.len] = 0;
|
|
|
|
return (bstr){out, b.len};
|
|
|
|
}
|