diff options
Diffstat (limited to 'sub/sd_ass.c')
| -rw-r--r-- | sub/sd_ass.c | 1035 |
1 files changed, 1035 insertions, 0 deletions
diff --git a/sub/sd_ass.c b/sub/sd_ass.c new file mode 100644 index 0000000..6742f6f --- /dev/null +++ b/sub/sd_ass.c @@ -0,0 +1,1035 @@ +/* + * This file is part of mpv. + * + * 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. + * + * mpv is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with mpv. If not, see <http://www.gnu.org/licenses/>. + */ + +#include <stdlib.h> +#include <assert.h> +#include <string.h> +#include <math.h> +#include <limits.h> + +#include <libavutil/common.h> +#include <ass/ass.h> + +#include "mpv_talloc.h" + +#include "config.h" +#include "options/m_config.h" +#include "options/options.h" +#include "common/common.h" +#include "common/msg.h" +#include "demux/demux.h" +#include "video/csputils.h" +#include "video/mp_image.h" +#include "dec_sub.h" +#include "ass_mp.h" +#include "sd.h" + +struct sd_ass_priv { + struct ass_library *ass_library; + struct ass_renderer *ass_renderer; + struct ass_track *ass_track; + struct ass_track *shadow_track; // for --sub-ass=no rendering + bool ass_configured; + bool is_converted; + struct lavc_conv *converter; + struct sd_filter **filters; + int num_filters; + bool clear_once; + bool on_top; + struct mp_ass_packer *packer; + struct sub_bitmap_copy_cache *copy_cache; + char last_text[500]; + struct mp_image_params video_params; + struct mp_image_params last_params; + struct mp_osd_res osd; + int64_t *seen_packets; + int num_seen_packets; + bool duration_unknown; +}; + +static void mangle_colors(struct sd *sd, struct sub_bitmaps *parts); +static void fill_plaintext(struct sd *sd, double pts); + +static const struct sd_filter_functions *const filters[] = { + // Note: list order defines filter order. + &sd_filter_sdh, +#if HAVE_POSIX + &sd_filter_regex, +#endif +#if HAVE_JAVASCRIPT + &sd_filter_jsre, +#endif + NULL, +}; + +// Add default styles, if the track does not have any styles yet. +// Apply style overrides if the user provides any. +static void mp_ass_add_default_styles(ASS_Track *track, struct mp_subtitle_opts *opts) +{ + if (opts->ass_styles_file && opts->ass_style_override) + ass_read_styles(track, opts->ass_styles_file, NULL); + + if (track->n_styles == 0) { + if (!track->PlayResY) { + track->PlayResX = MP_ASS_FONT_PLAYRESX; + 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"); + mp_ass_set_style(style, track->PlayResY, opts->sub_style); + } + + if (opts->ass_style_override) + ass_process_force_style(track); +} + +static const char *const font_mimetypes[] = { + "application/x-truetype-font", + "application/vnd.ms-opentype", + "application/x-font-ttf", + "application/x-font", // probably incorrect + "application/font-sfnt", + "font/collection", + "font/otf", + "font/sfnt", + "font/ttf", + NULL +}; + +static const char *const font_exts[] = {".ttf", ".ttc", ".otf", ".otc", NULL}; + +static bool attachment_is_font(struct mp_log *log, struct demux_attachment *f) +{ + if (!f->name || !f->type || !f->data || !f->data_size) + return false; + for (int n = 0; font_mimetypes[n]; n++) { + if (strcmp(font_mimetypes[n], f->type) == 0) + return true; + } + // fallback: match against file extension + char *ext = strlen(f->name) > 4 ? f->name + strlen(f->name) - 4 : ""; + for (int n = 0; font_exts[n]; n++) { + if (strcasecmp(ext, font_exts[n]) == 0) { + mp_warn(log, "Loading font attachment '%s' with MIME type %s. " + "Assuming this is a broken Matroska file, which was " + "muxed without setting a correct font MIME type.\n", + f->name, f->type); + return true; + } + } + return false; +} + +static void add_subtitle_fonts(struct sd *sd) +{ + struct sd_ass_priv *ctx = sd->priv; + struct mp_subtitle_opts *opts = sd->opts; + if (!opts->ass_enabled || !opts->use_embedded_fonts || !sd->attachments) + return; + for (int i = 0; i < sd->attachments->num_entries; i++) { + struct demux_attachment *f = &sd->attachments->entries[i]; + if (attachment_is_font(sd->log, f)) + ass_add_font(ctx->ass_library, f->name, f->data, f->data_size); + } +} + +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); + } + } +} + +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); + + mp_ass_configure_fonts(ctx->ass_renderer, sd->opts->sub_style, + sd->global, sd->log); + } +} + +static void assobjects_init(struct sd *sd) +{ + struct sd_ass_priv *ctx = sd->priv; + struct mp_subtitle_opts *opts = sd->opts; + + ctx->ass_library = mp_ass_init(sd->global, sd->opts->sub_style, sd->log); + ass_set_extract_fonts(ctx->ass_library, opts->use_embedded_fonts); + + add_subtitle_fonts(sd); + + if (opts->ass_style_override) + ass_set_style_overrides(ctx->ass_library, opts->ass_style_override_list); + + ctx->ass_track = ass_new_track(ctx->ass_library); + ctx->ass_track->track_type = TRACK_TYPE_ASS; + + ctx->shadow_track = ass_new_track(ctx->ass_library); + ctx->shadow_track->PlayResX = MP_ASS_FONT_PLAYRESX; + ctx->shadow_track->PlayResY = MP_ASS_FONT_PLAYRESY; + mp_ass_add_default_styles(ctx->shadow_track, opts); + + char *extradata = sd->codec->extradata; + int extradata_size = sd->codec->extradata_size; + if (ctx->converter) { + extradata = lavc_conv_get_extradata(ctx->converter); + extradata_size = extradata ? strlen(extradata) : 0; + } + if (extradata) + ass_process_codec_private(ctx->ass_track, extradata, extradata_size); + + mp_ass_add_default_styles(ctx->ass_track, opts); + +#if LIBASS_VERSION >= 0x01302000 + ass_set_check_readorder(ctx->ass_track, sd->opts->sub_clear_on_seek ? 0 : 1); +#endif + + enable_output(sd, true); +} + +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; + ctx->converter = lavc_conv_create(sd->log, sd->codec); + if (!ctx->converter) + return -1; + + if (strcmp(sd->codec->codec, "eia_608") == 0) + ctx->duration_unknown = 1; + } + + assobjects_init(sd); + filters_init(sd); + + ctx->packer = mp_ass_packer_alloc(ctx); + + return 0; +} + +// 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); +} + +// 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; +} + +#define UNKNOWN_DURATION (INT_MAX / 1000) + +static void decode(struct sd *sd, struct demux_packet *packet) +{ + struct sd_ass_priv *ctx = sd->priv; + ASS_Track *track = ctx->ass_track; + if (ctx->converter) { + if (!sd->opts->sub_clear_on_seek && packet->pos >= 0 && + check_packet_seen(sd, packet->pos)) + return; + + double sub_pts = 0; + double sub_duration = 0; + char **r = lavc_conv_decode(ctx->converter, packet, &sub_pts, + &sub_duration); + if (sd->opts->sub_stretch_durations || + packet->duration < 0 || sub_duration == UINT32_MAX) { + if (!ctx->duration_unknown) { + MP_WARN(sd, "Subtitle with unknown duration.\n"); + ctx->duration_unknown = true; + } + sub_duration = UNKNOWN_DURATION; + } + + for (int n = 0; r && r[n]; n++) { + struct demux_packet pkt2 = { + .pts = sub_pts, + .duration = sub_duration, + .buffer = r[n], + .len = strlen(r[n]), + }; + filter_and_add(sd, &pkt2); + } + if (ctx->duration_unknown) { + for (int n = track->n_events - 2; n >= 0; n--) { + if (track->events[n].Duration == UNKNOWN_DURATION * 1000) { + 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; + } + } + } + } + } else { + // Note that for this packet format, libass has an internal mechanism + // for discarding duplicate (already seen) packets. + filter_and_add(sd, packet); + } +} + +static void configure_ass(struct sd *sd, struct mp_osd_res *dim, + bool converted, ASS_Track *track) +{ + struct mp_subtitle_opts *opts = sd->opts; + struct sd_ass_priv *ctx = sd->priv; + ASS_Renderer *priv = ctx->ass_renderer; + + 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; + float set_sub_pos = 0.0f; + 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 + if (converted || opts->ass_style_override == 3) { // 'force' + 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; + } + if (converted || opts->ass_style_override) { + set_sub_pos = 100.0f - opts->sub_pos; + set_line_spacing = opts->ass_line_spacing; + set_hinting = opts->ass_hinting; + set_font_scale = opts->sub_scale; + } + if (set_scale_with_window) { + int vidh = dim->h - (dim->mt + dim->mb); + set_font_scale *= dim->h / (float)MPMAX(vidh, 1); + } + if (!set_scale_by_window) { + double factor = dim->h / 720.0; + if (factor != 0.0) + set_font_scale /= factor; + } + ass_set_use_margins(priv, set_use_margins); + ass_set_line_position(priv, set_sub_pos); + ass_set_shaper(priv, opts->ass_shaper); + int set_force_flags = 0; + if (total_override) + set_force_flags |= ASS_OVERRIDE_BIT_STYLE | ASS_OVERRIDE_BIT_SELECTIVE_FONT_SCALE; + if (opts->ass_style_override == 4) // 'scale' + set_force_flags |= ASS_OVERRIDE_BIT_SELECTIVE_FONT_SCALE; + if (converted) + set_force_flags |= ASS_OVERRIDE_BIT_ALIGNMENT; +#ifdef ASS_JUSTIFY_AUTO + if ((converted || opts->ass_style_override) && opts->ass_justify) + set_force_flags |= ASS_OVERRIDE_BIT_JUSTIFY; +#endif + ass_set_selective_style_override_enabled(priv, set_force_flags); + ASS_Style style = {0}; + mp_ass_set_style(&style, MP_ASS_FONT_PLAYRESY, opts->sub_style); + ass_set_selective_style_override(priv, &style); + free(style.FontName); + if (converted && track->default_style < track->n_styles) { + mp_ass_set_style(track->styles + track->default_style, + track->PlayResY, opts->sub_style); + } + ass_set_font_scale(priv, set_font_scale); + ass_set_hinting(priv, set_hinting); + ass_set_line_spacing(priv, set_line_spacing); +#if LIBASS_VERSION >= 0x01600010 + if (converted) + ass_track_set_feature(track, ASS_FEATURE_WRAP_UNICODE, 1); +#endif + if (converted) { + bool override_playres = true; + 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) + 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. + double fix_margins = track->PlayResX / (double)MP_ASS_FONT_PLAYRESX; + track->styles->MarginL = round(track->styles->MarginL * fix_margins); + track->styles->MarginR = round(track->styles->MarginR * fix_margins); + } + } +} + +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"); +} + +#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); + + if (!sd->opts->sub_fix_timing || sd->opts->ass_style_override == 0) + 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. + if (ev[0]->Style != ev[1]->Style || has_overrides(ev[0]->Text) || + has_overrides(ev[1]->Text)) + 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 + +static struct sub_bitmaps *get_bitmaps(struct sd *sd, struct mp_osd_res dim, + int format, double pts) +{ + struct sd_ass_priv *ctx = sd->priv; + struct mp_subtitle_opts *opts = sd->opts; + bool no_ass = !opts->ass_enabled || ctx->on_top || + opts->ass_style_override == 5; + bool converted = ctx->is_converted || no_ass; + ASS_Track *track = no_ass ? ctx->shadow_track : ctx->ass_track; + ASS_Renderer *renderer = ctx->ass_renderer; + struct sub_bitmaps *res = &(struct sub_bitmaps){0}; + + // Always update the osd_res + struct mp_osd_res old_osd = ctx->osd; + ctx->osd = dim; + + if (pts == MP_NOPTS_VALUE || !renderer) + goto done; + + // 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. + if (opts->sub_forced_events_only) + goto done; + + double scale = dim.display_par; + if (!converted && (!opts->ass_style_override || + opts->ass_vsfilter_aspect_compat)) + { + // Let's use the original video PAR for vsfilter compatibility: + double par = ctx->video_params.p_w / (double)ctx->video_params.p_h; + if (isnormal(par)) + scale *= par; + } + if (!ctx->ass_configured || !osd_res_equals(old_osd, ctx->osd)) { + configure_ass(sd, &dim, converted, track); + ctx->ass_configured = true; + } + ass_set_pixel_aspect(renderer, scale); + if (!converted && (!opts->ass_style_override || + opts->ass_vsfilter_blur_compat)) + { + ass_set_storage_size(renderer, ctx->video_params.w, ctx->video_params.h); + } else { + ass_set_storage_size(renderer, 0, 0); + } + long long ts = find_timestamp(sd, pts); + if (ctx->duration_unknown && pts != MP_NOPTS_VALUE) { + mp_ass_flush_old_events(track, ts); + ctx->num_seen_packets = 0; + sd->preload_ok = false; + } + + if (no_ass) + fill_plaintext(sd, pts); + + int changed; + ASS_Image *imgs = ass_render_frame(renderer, track, ts, &changed); + mp_ass_packer_pack(ctx->packer, &imgs, 1, changed, format, res); + +done: + // mangle_colors() modifies the color field, so copy the thing _before_. + res = sub_bitmaps_copy(&ctx->copy_cache, res); + + if (!converted && res) + mangle_colors(sd, res); + + return res; +} + +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; + const char *open_tag_pos = NULL; + 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; + // 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; + } + } 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] == '{') { + open_tag_pos = in; + in += 1; + in_tag = true; + } else { + if (!in_drawing) + append(b, in[0]); + in += 1; + } + } + } + // A '{' without a closing '}' is always visible. + if (in_tag) { + while (*open_tag_pos) + append(b, *open_tag_pos++); + } +} + +// 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; +} + +static char *get_text_buf(struct sd *sd, double pts, enum sd_text_type type) +{ + struct sd_ass_priv *ctx = sd->priv; + ASS_Track *track = ctx->ass_track; + + if (pts == MP_NOPTS_VALUE) + return NULL; + long long ipts = find_timestamp(sd, pts); + + 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; + if (ipts >= event->Start && ipts < event->Start + event->Duration) { + if (event->Text) { + int start = b.len; + if (type == SD_TEXT_TYPE_PLAIN) { + ass_to_plaintext(&b, event->Text); + } else { + char *t = event->Text; + while (*t) + append(&b, *t++); + } + if (is_whitespace_only(&b.start[start], b.len - start)) { + b.len = start; + } else { + append(&b, '\n'); + } + } + } + } + + 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; +} + +static char *get_text(struct sd *sd, double pts, enum sd_text_type type) +{ + return talloc_strdup(NULL, get_text_buf(sd, pts, type)); +} + +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 }; + + if (pts == MP_NOPTS_VALUE) + 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; +} + +static void fill_plaintext(struct sd *sd, double pts) +{ + struct sd_ass_priv *ctx = sd->priv; + ASS_Track *track = ctx->shadow_track; + + ass_flush_events(track); + + char *text = get_text_buf(sd, pts, SD_TEXT_TYPE_PLAIN); + if (!text) + return; + + bstr dst = {0}; + + if (ctx->on_top) + bstr_xappend(NULL, &dst, bstr0("{\\a6}")); + + 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++; + } + + if (!dst.start) + 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); + + talloc_free(dst.start); +} + +static void reset(struct sd *sd) +{ + struct sd_ass_priv *ctx = sd->priv; + if (sd->opts->sub_clear_on_seek || ctx->duration_unknown || ctx->clear_once) { + ass_flush_events(ctx->ass_track); + ctx->num_seen_packets = 0; + sd->preload_ok = false; + ctx->clear_once = false; + } + if (ctx->converter) + lavc_conv_reset(ctx->converter); +} + +static void uninit(struct sd *sd) +{ + struct sd_ass_priv *ctx = sd->priv; + + filters_destroy(sd); + if (ctx->converter) + lavc_conv_uninit(ctx->converter); + assobjects_destroy(sd); + talloc_free(ctx->copy_cache); +} + +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; + long long ts = llrint(a[0] * 1000.0); + long long res = ass_step_sub(ctx->ass_track, ts, a[1]); + if (!res) + return false; + // Try to account for overlapping durations + a[0] += res / 1000.0 + SUB_SEEK_OFFSET; + return true; + } + case SD_CTRL_SET_VIDEO_PARAMS: + ctx->video_params = *(struct mp_image_params *)arg; + return CONTROL_OK; + case SD_CTRL_SET_TOP: + ctx->on_top = *(bool *)arg; + return CONTROL_OK; + 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 + reset(sd); + } + if (flags & UPDATE_SUB_HARD) { + // ass_track will be recreated, so clear duplicate cache + ctx->clear_once = true; + reset(sd); + assobjects_destroy(sd); + assobjects_init(sd); + } + ctx->ass_configured = false; // ass always needs to be reconfigured + return CONTROL_OK; + } + default: + return CONTROL_UNKNOWN; + } +} + +const struct sd_functions sd_ass = { + .name = "ass", + .accept_packets_in_advance = true, + .init = init, + .decode = decode, + .get_bitmaps = get_bitmaps, + .get_text = get_text, + .get_times = get_times, + .control = control, + .reset = reset, + .select = enable_output, + .uninit = uninit, +}; + +// Disgusting hack for (xy-)vsfilter color compatibility. +static void mangle_colors(struct sd *sd, struct sub_bitmaps *parts) +{ + struct mp_subtitle_opts *opts = sd->opts; + struct sd_ass_priv *ctx = sd->priv; + enum mp_csp csp = 0; + enum mp_csp_levels levels = 0; + if (opts->ass_vsfilter_color_compat == 0) // "no" + return; + bool force_601 = opts->ass_vsfilter_color_compat == 3; + ASS_Track *track = ctx->ass_track; + 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) { + params.color = (struct mp_colorspace){ + .space = MP_CSP_BT_709, + .levels = MP_CSP_LEVELS_TV, + }; + } + + if ((csp == params.color.space && levels == params.color.levels) || + params.color.space == MP_CSP_RGB) // Even VSFilter doesn't mangle on RGB video + return; + + bool basic_conv = params.color.space == MP_CSP_BT_709 && + params.color.levels == MP_CSP_LEVELS_TV && + 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; + + if (params.color.space != ctx->last_params.color.space || + params.color.levels != ctx->last_params.color.levels) + { + int msgl = basic_conv ? MSGL_V : MSGL_WARN; + ctx->last_params = params; + MP_MSG(sd, msgl, "mangling colors like vsfilter: " + "RGB -> %s %s -> %s %s -> RGB\n", + m_opt_choice_str(mp_csp_names, csp), + m_opt_choice_str(mp_csp_levels_names, levels), + m_opt_choice_str(mp_csp_names, params.color.space), + m_opt_choice_str(mp_csp_names, params.color.levels)); + } + + // Conversion that VSFilter would use + struct mp_csp_params vs_params = MP_CSP_PARAMS_DEFAULTS; + vs_params.color.space = csp; + vs_params.color.levels = levels; + struct mp_cmat vs_yuv2rgb, vs_rgb2yuv; + mp_get_csp_matrix(&vs_params, &vs_yuv2rgb); + mp_invert_cmat(&vs_rgb2yuv, &vs_yuv2rgb); + + // Proper conversion to RGB + struct mp_csp_params rgb_params = MP_CSP_PARAMS_DEFAULTS; + rgb_params.color = params.color; + struct mp_cmat vs2rgb; + mp_get_csp_matrix(&rgb_params, &vs2rgb); + + 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; + int a = 0xff - (color & 0xff); + 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); + } +} + +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; +} + +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}; +} |