diff options
Diffstat (limited to 'sub/sd_lavc.c')
| -rw-r--r-- | sub/sd_lavc.c | 676 |
1 files changed, 676 insertions, 0 deletions
diff --git a/sub/sd_lavc.c b/sub/sd_lavc.c new file mode 100644 index 0000000..30aa641 --- /dev/null +++ b/sub/sd_lavc.c @@ -0,0 +1,676 @@ +/* + * 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 <math.h> + +#include <libavcodec/avcodec.h> +#include <libavutil/common.h> +#include <libavutil/intreadwrite.h> +#include <libavutil/opt.h> + +#include "mpv_talloc.h" +#include "common/msg.h" +#include "common/av_common.h" +#include "demux/stheader.h" +#include "options/options.h" +#include "video/mp_image.h" +#include "video/out/bitmap_packer.h" +#include "img_convert.h" +#include "sd.h" +#include "dec_sub.h" + +#define MAX_QUEUE 4 + +struct sub { + bool valid; + AVSubtitle avsub; + struct sub_bitmap *inbitmaps; + int count; + struct mp_image *data; + int bound_w, bound_h; + int src_w, src_h; + double pts; + double endpts; + int64_t id; +}; + +struct seekpoint { + double pts; + double endpts; +}; + +struct sd_lavc_priv { + AVCodecContext *avctx; + AVPacket *avpkt; + AVRational pkt_timebase; + struct sub subs[MAX_QUEUE]; // most recent event first + struct sub_bitmap *outbitmaps; + struct sub_bitmap *prevret; + int prevret_num; + int64_t displayed_id; + int64_t new_id; + struct mp_image_params video_params; + double current_pts; + struct seekpoint *seekpoints; + int num_seekpoints; + struct bitmap_packer *packer; +}; + +static int init(struct sd *sd) +{ + enum AVCodecID cid = mp_codec_to_av_codec_id(sd->codec->codec); + + // Supported codecs must be known to decode to paletted bitmaps + switch (cid) { + case AV_CODEC_ID_DVB_SUBTITLE: + case AV_CODEC_ID_DVB_TELETEXT: + case AV_CODEC_ID_HDMV_PGS_SUBTITLE: + case AV_CODEC_ID_XSUB: + case AV_CODEC_ID_DVD_SUBTITLE: + break; + default: + return -1; + } + + struct sd_lavc_priv *priv = talloc_zero(NULL, struct sd_lavc_priv); + AVCodecContext *ctx = NULL; + const AVCodec *sub_codec = avcodec_find_decoder(cid); + if (!sub_codec) + goto error; + ctx = avcodec_alloc_context3(sub_codec); + if (!ctx) + goto error; + priv->avpkt = av_packet_alloc(); + if (!priv->avpkt) + goto error; + if (mp_set_avctx_codec_headers(ctx, sd->codec) < 0) + goto error; + priv->pkt_timebase = mp_get_codec_timebase(sd->codec); + ctx->pkt_timebase = priv->pkt_timebase; + if (avcodec_open2(ctx, sub_codec, NULL) < 0) + goto error; + priv->avctx = ctx; + sd->priv = priv; + priv->displayed_id = -1; + priv->current_pts = MP_NOPTS_VALUE; + priv->packer = talloc_zero(priv, struct bitmap_packer); + return 0; + + error: + MP_FATAL(sd, "Could not open libavcodec subtitle decoder\n"); + avcodec_free_context(&ctx); + mp_free_av_packet(&priv->avpkt); + talloc_free(priv); + return -1; +} + +static void clear_sub(struct sub *sub) +{ + sub->count = 0; + sub->pts = MP_NOPTS_VALUE; + sub->endpts = MP_NOPTS_VALUE; + if (sub->valid) + avsubtitle_free(&sub->avsub); + sub->valid = false; +} + +static void alloc_sub(struct sd_lavc_priv *priv) +{ + clear_sub(&priv->subs[MAX_QUEUE - 1]); + struct sub tmp = priv->subs[MAX_QUEUE - 1]; + for (int n = MAX_QUEUE - 1; n > 0; n--) + priv->subs[n] = priv->subs[n - 1]; + priv->subs[0] = tmp; + // clear only some fields; the memory allocs can be reused + priv->subs[0].valid = false; + priv->subs[0].count = 0; + priv->subs[0].src_w = 0; + priv->subs[0].src_h = 0; + priv->subs[0].id = priv->new_id++; +} + +static void convert_pal(uint32_t *colors, size_t count, bool gray) +{ + for (int n = 0; n < count; n++) { + uint32_t c = colors[n]; + uint32_t b = c & 0xFF; + uint32_t g = (c >> 8) & 0xFF; + uint32_t r = (c >> 16) & 0xFF; + uint32_t a = (c >> 24) & 0xFF; + if (gray) + r = g = b = (r + g + b) / 3; + // from straight to pre-multiplied alpha + b = b * a / 255; + g = g * a / 255; + r = r * a / 255; + colors[n] = b | (g << 8) | (r << 16) | (a << 24); + } +} + +// Initialize sub from sub->avsub. +static void read_sub_bitmaps(struct sd *sd, struct sub *sub) +{ + struct mp_subtitle_opts *opts = sd->opts; + struct sd_lavc_priv *priv = sd->priv; + AVSubtitle *avsub = &sub->avsub; + + MP_TARRAY_GROW(priv, sub->inbitmaps, avsub->num_rects); + + packer_set_size(priv->packer, avsub->num_rects); + + // If we blur, we want a transparent region around the bitmap data to + // avoid "cut off" artifacts on the borders. + bool apply_blur = opts->sub_gauss != 0.0f; + int extend = apply_blur ? 5 : 0; + // Assume consumers may use bilinear scaling on it (2x2 filter) + int padding = 1 + extend; + + priv->packer->padding = padding; + + // For the sake of libswscale, which in some cases takes sub-rects as + // source images, and wants 16 byte start pointer and stride alignment. + int align = 4; + + for (int i = 0; i < avsub->num_rects; i++) { + struct AVSubtitleRect *r = avsub->rects[i]; + struct sub_bitmap *b = &sub->inbitmaps[sub->count]; + + if (r->type != SUBTITLE_BITMAP) { + MP_ERR(sd, "unsupported subtitle type from libavcodec\n"); + continue; + } + if (!(r->flags & AV_SUBTITLE_FLAG_FORCED) && opts->sub_forced_events_only) + continue; + if (r->w <= 0 || r->h <= 0) + continue; + + b->bitmap = r; // save for later (dumb hack to avoid more complexity) + + priv->packer->in[sub->count] = (struct pos){r->w + (align - 1), r->h}; + sub->count++; + } + + priv->packer->count = sub->count; + + if (packer_pack(priv->packer) < 0) { + MP_ERR(sd, "Unable to pack subtitle bitmaps.\n"); + sub->count = 0; + } + + if (!sub->count) + return; + + struct pos bb[2]; + packer_get_bb(priv->packer, bb); + + sub->bound_w = bb[1].x; + sub->bound_h = bb[1].y; + + if (!sub->data || sub->data->w < sub->bound_w || sub->data->h < sub->bound_h) { + talloc_free(sub->data); + sub->data = mp_image_alloc(IMGFMT_BGRA, priv->packer->w, priv->packer->h); + if (!sub->data) { + sub->count = 0; + return; + } + talloc_steal(priv, sub->data); + } + + if (!mp_image_make_writeable(sub->data)) { + sub->count = 0; + return; + } + + for (int i = 0; i < sub->count; i++) { + struct sub_bitmap *b = &sub->inbitmaps[i]; + struct pos pos = priv->packer->result[i]; + struct AVSubtitleRect *r = b->bitmap; + uint8_t **data = r->data; + int *linesize = r->linesize; + b->w = r->w; + b->h = r->h; + b->x = r->x; + b->y = r->y; + + // Choose such that the extended start position is aligned. + pos.x = MP_ALIGN_UP(pos.x - extend, align) + extend; + + b->src_x = pos.x; + b->src_y = pos.y; + b->stride = sub->data->stride[0]; + b->bitmap = sub->data->planes[0] + pos.y * b->stride + pos.x * 4; + + sub->src_w = MPMAX(sub->src_w, b->x + b->w); + sub->src_h = MPMAX(sub->src_h, b->y + b->h); + + assert(r->nb_colors > 0); + assert(r->nb_colors <= 256); + uint32_t pal[256] = {0}; + memcpy(pal, data[1], r->nb_colors * 4); + convert_pal(pal, 256, opts->sub_gray); + + for (int y = -padding; y < b->h + padding; y++) { + uint32_t *out = (uint32_t*)((char*)b->bitmap + y * b->stride); + int start = 0; + for (int x = -padding; x < 0; x++) + out[x] = 0; + if (y >= 0 && y < b->h) { + uint8_t *in = data[0] + y * linesize[0]; + for (int x = 0; x < b->w; x++) + *out++ = pal[*in++]; + start = b->w; + } + for (int x = start; x < b->w + padding; x++) + *out++ = 0; + } + + b->bitmap = (char*)b->bitmap - extend * b->stride - extend * 4; + b->src_x -= extend; + b->src_y -= extend; + b->x -= extend; + b->y -= extend; + b->w += extend * 2; + b->h += extend * 2; + + if (apply_blur) + mp_blur_rgba_sub_bitmap(b, opts->sub_gauss); + } +} + +static void decode(struct sd *sd, struct demux_packet *packet) +{ + struct mp_subtitle_opts *opts = sd->opts; + struct sd_lavc_priv *priv = sd->priv; + AVCodecContext *ctx = priv->avctx; + double pts = packet->pts; + double endpts = MP_NOPTS_VALUE; + AVSubtitle sub; + + if (pts == MP_NOPTS_VALUE) + MP_WARN(sd, "Subtitle with unknown start time.\n"); + + mp_set_av_packet(priv->avpkt, packet, &priv->pkt_timebase); + + if (ctx->codec_id == AV_CODEC_ID_DVB_TELETEXT) { + char page[4]; + snprintf(page, sizeof(page), "%d", opts->teletext_page); + av_opt_set(ctx, "txt_page", page, AV_OPT_SEARCH_CHILDREN); + } + + int got_sub; + int res = avcodec_decode_subtitle2(ctx, &sub, &got_sub, priv->avpkt); + if (res < 0 || !got_sub) + return; + + if (sub.pts != AV_NOPTS_VALUE) + pts = sub.pts / (double)AV_TIME_BASE; + + if (pts != MP_NOPTS_VALUE) { + if (sub.end_display_time > sub.start_display_time && + sub.end_display_time != UINT32_MAX) + { + endpts = pts + sub.end_display_time / 1000.0; + } + pts += sub.start_display_time / 1000.0; + + // set end time of previous sub + struct sub *prev = &priv->subs[0]; + if (prev->valid) { + if (prev->endpts == MP_NOPTS_VALUE || prev->endpts > pts) + prev->endpts = pts; + + if (opts->sub_fix_timing && pts - prev->endpts <= SUB_GAP_THRESHOLD) + prev->endpts = pts; + + for (int n = 0; n < priv->num_seekpoints; n++) { + if (priv->seekpoints[n].pts == prev->pts) { + priv->seekpoints[n].endpts = prev->endpts; + break; + } + } + } + + // This subtitle packet only signals the end of subtitle display. + if (!sub.num_rects) { + avsubtitle_free(&sub); + return; + } + } + + alloc_sub(priv); + struct sub *current = &priv->subs[0]; + + current->valid = true; + current->pts = pts; + current->endpts = endpts; + current->avsub = sub; + + read_sub_bitmaps(sd, current); + + if (pts != MP_NOPTS_VALUE) { + for (int n = 0; n < priv->num_seekpoints; n++) { + if (priv->seekpoints[n].pts == pts) + goto skip; + } + // Set arbitrary limit as safe-guard against insane files. + if (priv->num_seekpoints >= 10000) + MP_TARRAY_REMOVE_AT(priv->seekpoints, priv->num_seekpoints, 0); + MP_TARRAY_APPEND(priv, priv->seekpoints, priv->num_seekpoints, + (struct seekpoint){.pts = pts, .endpts = endpts}); + skip: ; + } +} + +static struct sub *get_current(struct sd_lavc_priv *priv, double pts) +{ + struct sub *current = NULL; + for (int n = 0; n < MAX_QUEUE; n++) { + struct sub *sub = &priv->subs[n]; + if (!sub->valid) + continue; + if (pts == MP_NOPTS_VALUE || + ((sub->pts == MP_NOPTS_VALUE || pts + 1e-6 >= sub->pts) && + (sub->endpts == MP_NOPTS_VALUE || pts + 1e-6 < sub->endpts))) + { + // Ignore "trailing" subtitles with unknown length after 1 minute. + if (sub->endpts == MP_NOPTS_VALUE && pts >= sub->pts + 60) + break; + current = sub; + break; + } + } + return current; +} + +static struct sub_bitmaps *get_bitmaps(struct sd *sd, struct mp_osd_res d, + int format, double pts) +{ + struct sd_lavc_priv *priv = sd->priv; + struct mp_subtitle_opts *opts = sd->opts; + + priv->current_pts = pts; + + struct sub *current = get_current(priv, pts); + + if (!current) + return NULL; + + MP_TARRAY_GROW(priv, priv->outbitmaps, current->count); + for (int n = 0; n < current->count; n++) + priv->outbitmaps[n] = current->inbitmaps[n]; + + struct sub_bitmaps *res = &(struct sub_bitmaps){0}; + res->parts = priv->outbitmaps; + res->num_parts = current->count; + if (priv->displayed_id != current->id) + res->change_id++; + priv->displayed_id = current->id; + res->packed = current->data; + res->packed_w = current->bound_w; + res->packed_h = current->bound_h; + res->format = SUBBITMAP_BGRA; + + double video_par = 0; + if (priv->avctx->codec_id == AV_CODEC_ID_DVD_SUBTITLE && + opts->stretch_dvd_subs) + { + // For DVD subs, try to keep the subtitle PAR at display PAR. + double par = priv->video_params.p_w / (double)priv->video_params.p_h; + if (isnormal(par)) + video_par = par; + } + if (priv->avctx->codec_id == AV_CODEC_ID_HDMV_PGS_SUBTITLE) + video_par = -1; + if (opts->stretch_image_subs) + d.ml = d.mr = d.mt = d.mb = 0; + int w = priv->avctx->width; + int h = priv->avctx->height; + if (w <= 0 || h <= 0 || opts->image_subs_video_res) { + w = priv->video_params.w; + h = priv->video_params.h; + } + if (current->src_w > w || current->src_h > h) { + w = MPMAX(priv->video_params.w, current->src_w); + h = MPMAX(priv->video_params.h, current->src_h); + } + + if (opts->sub_pos != 100.0f && opts->ass_style_override) { + float offset = (100.0f - opts->sub_pos) / 100.0f * h; + + for (int n = 0; n < res->num_parts; n++) { + struct sub_bitmap *sub = &res->parts[n]; + + // Decide by heuristic whether this is a sub-title or something + // else (top-title, covering whole screen). + if (sub->y < h / 2) + continue; + + // Allow moving up the subtitle, but only until it clips. + sub->y = MPMAX(sub->y - offset, 0); + sub->y = MPMIN(sub->y + sub->h, h) - sub->h; + } + } + + osd_rescale_bitmaps(res, w, h, d, video_par); + + if (opts->sub_scale != 1.0 && opts->ass_style_override) { + for (int n = 0; n < res->num_parts; n++) { + struct sub_bitmap *sub = &res->parts[n]; + + float shit = (opts->sub_scale - 1.0f) / 2; + + // Fortunately VO isn't supposed to give a FUCKING FUCK about + // whether the sub might e.g. go outside of the screen. + sub->x -= sub->dw * shit; + sub->y -= sub->dh * shit; + sub->dw += sub->dw * shit * 2; + sub->dh += sub->dh * shit * 2; + } + } + + if (priv->prevret_num != res->num_parts) + res->change_id++; + + if (!res->change_id) { + assert(priv->prevret_num == res->num_parts); + for (int n = 0; n < priv->prevret_num; n++) { + struct sub_bitmap *a = &res->parts[n]; + struct sub_bitmap *b = &priv->prevret[n]; + + if (a->x != b->x || a->y != b->y || + a->dw != b->dw || a->dh != b->dh) + { + res->change_id++; + break; + } + } + } + + priv->prevret_num = res->num_parts; + MP_TARRAY_GROW(priv, priv->prevret, priv->prevret_num); + memcpy(priv->prevret, res->parts, res->num_parts * sizeof(priv->prevret[0])); + + return sub_bitmaps_copy(NULL, res); +} + +static struct sd_times get_times(struct sd *sd, double pts) +{ + struct sd_lavc_priv *priv = sd->priv; + struct sd_times res = { .start = MP_NOPTS_VALUE, .end = MP_NOPTS_VALUE }; + + if (pts == MP_NOPTS_VALUE) + return res; + + struct sub *current = get_current(priv, pts); + + if (!current) + return res; + + res.start = current->pts; + res.end = current->endpts; + + return res; +} + +static bool accepts_packet(struct sd *sd, double min_pts) +{ + struct sd_lavc_priv *priv = sd->priv; + + double pts = priv->current_pts; + if (min_pts != MP_NOPTS_VALUE) { + // guard against bogus rendering PTS in the future. + if (pts == MP_NOPTS_VALUE || min_pts < pts) + pts = min_pts; + // Heuristic: we assume rendering cannot lag behind more than 1 second + // behind decoding. + if (pts + 1 < min_pts) + pts = min_pts; + } + + int last_needed = -1; + for (int n = 0; n < MAX_QUEUE; n++) { + struct sub *sub = &priv->subs[n]; + if (!sub->valid) + continue; + if (pts == MP_NOPTS_VALUE || + ((sub->pts == MP_NOPTS_VALUE || sub->pts >= pts) || + (sub->endpts == MP_NOPTS_VALUE || pts < sub->endpts))) + { + last_needed = n; + } + } + // We can accept a packet if it wouldn't overflow the fixed subtitle queue. + // We assume that get_bitmaps() never decreases the PTS. + return last_needed + 1 < MAX_QUEUE; +} + +static void reset(struct sd *sd) +{ + struct sd_lavc_priv *priv = sd->priv; + + for (int n = 0; n < MAX_QUEUE; n++) + clear_sub(&priv->subs[n]); + // lavc might not do this right for all codecs; may need close+reopen + avcodec_flush_buffers(priv->avctx); + + priv->current_pts = MP_NOPTS_VALUE; +} + +static void uninit(struct sd *sd) +{ + struct sd_lavc_priv *priv = sd->priv; + + for (int n = 0; n < MAX_QUEUE; n++) + clear_sub(&priv->subs[n]); + avcodec_free_context(&priv->avctx); + mp_free_av_packet(&priv->avpkt); + talloc_free(priv); +} + +static int compare_seekpoint(const void *pa, const void *pb) +{ + const struct seekpoint *a = pa, *b = pb; + return a->pts == b->pts ? 0 : (a->pts < b->pts ? -1 : +1); +} + +// taken from ass_step_sub(), libass (ISC) +static double step_sub(struct sd *sd, double now, int movement) +{ + struct sd_lavc_priv *priv = sd->priv; + int best = -1; + double target = now; + int direction = (movement > 0 ? 1 : -1) * !!movement; + + if (priv->num_seekpoints == 0) + return MP_NOPTS_VALUE; + + qsort(priv->seekpoints, priv->num_seekpoints, sizeof(priv->seekpoints[0]), + compare_seekpoint); + + do { + int closest = -1; + double closest_time = 0; + for (int i = 0; i < priv->num_seekpoints; i++) { + struct seekpoint *p = &priv->seekpoints[i]; + double start = p->pts; + if (direction < 0) { + double end = p->endpts == MP_NOPTS_VALUE ? INFINITY : p->endpts; + if (end < target) { + if (closest < 0 || end > closest_time) { + closest = i; + closest_time = end; + } + } + } else if (direction > 0) { + if (start > target) { + if (closest < 0 || start < closest_time) { + closest = i; + closest_time = start; + } + } + } else { + if (start < target) { + if (closest < 0 || start >= closest_time) { + closest = i; + closest_time = start; + } + } + } + } + if (closest < 0) + break; + target = closest_time + direction; + best = closest; + movement -= direction; + } while (movement); + + return best < 0 ? now : priv->seekpoints[best].pts; +} + +static int control(struct sd *sd, enum sd_ctrl cmd, void *arg) +{ + struct sd_lavc_priv *priv = sd->priv; + switch (cmd) { + case SD_CTRL_SUB_STEP: { + double *a = arg; + double res = step_sub(sd, a[0], a[1]); + if (res == MP_NOPTS_VALUE) + return false; + a[0] = res; + return true; + } + case SD_CTRL_SET_VIDEO_PARAMS: + priv->video_params = *(struct mp_image_params *)arg; + return CONTROL_OK; + default: + return CONTROL_UNKNOWN; + } +} + +const struct sd_functions sd_lavc = { + .name = "lavc", + .init = init, + .decode = decode, + .get_bitmaps = get_bitmaps, + .get_times = get_times, + .accepts_packet = accepts_packet, + .control = control, + .reset = reset, + .uninit = uninit, +}; |