diff options
author | wm4 <wm4@nowhere> | 2013-11-24 12:58:06 +0100 |
---|---|---|
committer | wm4 <wm4@nowhere> | 2013-11-24 14:44:58 +0100 |
commit | e5311586ab7641e0e1936473594bd9fbaa67bb2d (patch) | |
tree | 9d52ad39bb326e401b3ea368513c65a96ffb057a /sub/osd.c | |
parent | df8d00cc1fec3758e990d2e51e9830c43642e2b6 (diff) | |
download | mpv-e5311586ab7641e0e1936473594bd9fbaa67bb2d.tar.bz2 mpv-e5311586ab7641e0e1936473594bd9fbaa67bb2d.tar.xz |
Rename sub.c/.h to osd.c/.h
This was way too misleading. osd.c merely calls the subtitle renderers,
instead of actually dealing with subtitles.
Diffstat (limited to 'sub/osd.c')
-rw-r--r-- | sub/osd.c | 325 |
1 files changed, 325 insertions, 0 deletions
diff --git a/sub/osd.c b/sub/osd.c new file mode 100644 index 0000000000..4c1b2ff322 --- /dev/null +++ b/sub/osd.c @@ -0,0 +1,325 @@ +/* + * This file is part of MPlayer. + * + * MPlayer is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2 of the License, or + * (at your option) any later version. + * + * MPlayer 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 General Public License for more details. + * + * You should have received a copy of the GNU General Public License along + * with MPlayer; if not, write to the Free Software Foundation, Inc., + * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. + */ + +#include <stdio.h> +#include <stdlib.h> +#include <string.h> +#include <assert.h> + +#include <libavutil/common.h> + +#include "mpvcore/mp_common.h" + +#include "stream/stream.h" + +#include "osdep/timer.h" + +#include "talloc.h" +#include "mpvcore/options.h" +#include "mpvcore/mp_msg.h" +#include "osd.h" +#include "dec_sub.h" +#include "img_convert.h" +#include "draw_bmp.h" +#include "video/mp_image.h" +#include "video/mp_image_pool.h" + +static const struct osd_style_opts osd_style_opts_def = { + .font = "sans-serif", + .font_size = 45, + .color = {255, 255, 255, 255}, + .border_color = {0, 0, 0, 255}, + .shadow_color = {240, 240, 240, 128}, + .border_size = 2.5, + .shadow_offset = 0, + .margin_x = 25, + .margin_y = 10, +}; + +#define OPT_BASE_STRUCT struct osd_style_opts +const struct m_sub_options osd_style_conf = { + .opts = (m_option_t[]) { + OPT_STRING("font", font, 0), + OPT_FLOATRANGE("font-size", font_size, 0, 1, 9000), + OPT_COLOR("color", color, 0), + OPT_COLOR("border-color", border_color, 0), + OPT_COLOR("shadow-color", shadow_color, 0), + OPT_COLOR("back-color", back_color, 0), + OPT_FLOATRANGE("border-size", border_size, 0, 0, 10), + OPT_FLOATRANGE("shadow-offset", shadow_offset, 0, 0, 10), + OPT_FLOATRANGE("spacing", spacing, 0, -10, 10), + OPT_INTRANGE("margin-x", margin_x, 0, 0, 300), + OPT_INTRANGE("margin-y", margin_y, 0, 0, 600), + OPT_FLOATRANGE("blur", blur, 0, 0, 20), + {0} + }, + .size = sizeof(struct osd_style_opts), + .defaults = &osd_style_opts_def, +}; + +static bool osd_res_equals(struct mp_osd_res a, struct mp_osd_res b) +{ + return a.w == b.w && a.h == b.h && a.ml == b.ml && a.mt == b.mt + && a.mr == b.mr && a.mb == b.mb + && a.display_par == b.display_par + && a.video_par == b.video_par; +} + +struct osd_state *osd_create(struct MPOpts *opts, struct ass_library *asslib) +{ + struct osd_state *osd = talloc_zero(NULL, struct osd_state); + *osd = (struct osd_state) { + .opts = opts, + .ass_library = asslib, + .osd_text = talloc_strdup(osd, ""), + .sub_text = talloc_strdup(osd, ""), + .progbar_type = -1, + }; + + for (int n = 0; n < MAX_OSD_PARTS; n++) { + struct osd_object *obj = talloc_struct(osd, struct osd_object, { + .type = n, + }); + for (int i = 0; i < OSD_CONV_CACHE_MAX; i++) + obj->cache[i] = talloc_steal(obj, osd_conv_cache_new()); + osd->objs[n] = obj; + } + + osd->objs[OSDTYPE_SUB]->is_sub = true; // dec_sub.c + osd->objs[OSDTYPE_SUBTEXT]->is_sub = true; // osd_libass.c + + osd_init_backend(osd); + return osd; +} + +void osd_free(struct osd_state *osd) +{ + if (!osd) + return; + osd_destroy_backend(osd); + talloc_free(osd); +} + +static bool set_text(void *talloc_ctx, char **var, const char *text) +{ + if (!text) + text = ""; + if (strcmp(*var, text) == 0) + return true; + talloc_free(*var); + *var = talloc_strdup(talloc_ctx, text); + return false; +} + +void osd_set_text(struct osd_state *osd, const char *text) +{ + if (!set_text(osd, &osd->osd_text, text)) + osd_changed(osd, OSDTYPE_OSD); +} + +void osd_set_sub(struct osd_state *osd, const char *text) +{ + if (!set_text(osd, &osd->sub_text, text)) + osd_changed(osd, OSDTYPE_SUBTEXT); +} + +static void render_object(struct osd_state *osd, struct osd_object *obj, + struct mp_osd_res res, double video_pts, + const bool sub_formats[SUBBITMAP_COUNT], + struct sub_bitmaps *out_imgs) +{ + struct MPOpts *opts = osd->opts; + + bool formats[SUBBITMAP_COUNT]; + memcpy(formats, sub_formats, sizeof(formats)); + if (opts->force_rgba_osd) + formats[SUBBITMAP_LIBASS] = false; + + *out_imgs = (struct sub_bitmaps) {0}; + + if (!osd_res_equals(res, obj->vo_res)) + obj->force_redraw = true; + obj->vo_res = res; + + if (obj->type == OSDTYPE_SUB) { + if (osd->render_bitmap_subs && osd->dec_sub) { + double sub_pts = video_pts; + if (sub_pts != MP_NOPTS_VALUE) + sub_pts -= osd->video_offset - opts->sub_delay; + sub_get_bitmaps(osd->dec_sub, obj->vo_res, sub_pts, out_imgs); + } + } else if (obj->type == OSDTYPE_EXTERNAL2) { + if (osd->external2.format) { + *out_imgs = osd->external2; + osd->external2.bitmap_id = osd->external2.bitmap_pos_id = 0; + } + } else { + osd_object_get_bitmaps(osd, obj, out_imgs); + } + + if (obj->force_redraw) { + out_imgs->bitmap_id++; + out_imgs->bitmap_pos_id++; + } + + obj->force_redraw = false; + obj->vo_bitmap_id += out_imgs->bitmap_id; + obj->vo_bitmap_pos_id += out_imgs->bitmap_pos_id; + + if (out_imgs->num_parts == 0) + return; + + if (obj->cached.bitmap_id == obj->vo_bitmap_id + && obj->cached.bitmap_pos_id == obj->vo_bitmap_pos_id + && formats[obj->cached.format]) + { + *out_imgs = obj->cached; + return; + } + + out_imgs->render_index = obj->type; + out_imgs->bitmap_id = obj->vo_bitmap_id; + out_imgs->bitmap_pos_id = obj->vo_bitmap_pos_id; + + if (formats[out_imgs->format]) + return; + + bool cached = false; // do we have a copy of all the image data? + + if (out_imgs->format == SUBBITMAP_INDEXED && opts->sub_gray) + cached |= osd_conv_idx_to_gray(obj->cache[0], out_imgs); + + if (formats[SUBBITMAP_RGBA] && out_imgs->format == SUBBITMAP_INDEXED) + cached |= osd_conv_idx_to_rgba(obj->cache[1], out_imgs); + + if (out_imgs->format == SUBBITMAP_RGBA && opts->sub_gauss != 0.0f) + cached |= osd_conv_blur_rgba(obj->cache[2], out_imgs, opts->sub_gauss); + + // Do this conversion last to not trigger gauss blurring for ASS + if (formats[SUBBITMAP_RGBA] && out_imgs->format == SUBBITMAP_LIBASS) + cached |= osd_conv_ass_to_rgba(obj->cache[3], out_imgs); + + if (cached) + obj->cached = *out_imgs; +} + +// draw_flags is a bit field of OSD_DRAW_* constants +void osd_draw(struct osd_state *osd, struct mp_osd_res res, + double video_pts, int draw_flags, + const bool formats[SUBBITMAP_COUNT], + void (*cb)(void *ctx, struct sub_bitmaps *imgs), void *cb_ctx) +{ + if (draw_flags & OSD_DRAW_SUB_FILTER) + draw_flags |= OSD_DRAW_SUB_ONLY; + + if (!(draw_flags & OSD_DRAW_SUB_ONLY)) + osd->last_vo_res = res; + + for (int n = 0; n < MAX_OSD_PARTS; n++) { + struct osd_object *obj = osd->objs[n]; + + // Object is drawn into the video frame itself; don't draw twice + if (osd->render_subs_in_filter && obj->is_sub && + !(draw_flags & OSD_DRAW_SUB_FILTER)) + continue; + if ((draw_flags & OSD_DRAW_SUB_ONLY) && !obj->is_sub) + continue; + + struct sub_bitmaps imgs; + render_object(osd, obj, res, video_pts, formats, &imgs); + if (imgs.num_parts > 0) { + if (formats[imgs.format]) { + cb(cb_ctx, &imgs); + } else { + mp_msg(MSGT_OSD, MSGL_ERR, + "Can't render OSD part %d (format %d).\n", + obj->type, imgs.format); + } + } + } +} + +struct draw_on_image_closure { + struct osd_state *osd; + struct mp_image *dest; + struct mp_image_pool *pool; + bool changed; +}; + +static void draw_on_image(void *ctx, struct sub_bitmaps *imgs) +{ + struct draw_on_image_closure *closure = ctx; + struct osd_state *osd = closure->osd; + if (closure->pool) { + mp_image_pool_make_writeable(closure->pool, closure->dest); + } else { + mp_image_make_writeable(closure->dest); + } + mp_draw_sub_bitmaps(&osd->draw_cache, closure->dest, imgs); + talloc_steal(osd, osd->draw_cache); + closure->changed = true; +} + +// Calls mp_image_make_writeable() on the dest image if something is drawn. +// Returns whether anything was drawn. +bool osd_draw_on_image(struct osd_state *osd, struct mp_osd_res res, + double video_pts, int draw_flags, struct mp_image *dest) +{ + struct draw_on_image_closure closure = {osd, dest}; + osd_draw(osd, res, video_pts, draw_flags, mp_draw_sub_formats, + &draw_on_image, &closure); + return closure.changed; +} + +// Like osd_draw_on_image(), but if dest needs to be copied to make it +// writeable, allocate images from the given pool. (This is a minor +// optimization to reduce "real" image sized memory allocations.) +void osd_draw_on_image_p(struct osd_state *osd, struct mp_osd_res res, + double video_pts, int draw_flags, + struct mp_image_pool *pool, struct mp_image *dest) +{ + struct draw_on_image_closure closure = {osd, dest, pool}; + osd_draw(osd, res, video_pts, draw_flags, mp_draw_sub_formats, + &draw_on_image, &closure); +} + +void osd_changed(struct osd_state *osd, int new_value) +{ + for (int n = 0; n < MAX_OSD_PARTS; n++) { + if (osd->objs[n]->type == new_value) + osd->objs[n]->force_redraw = true; + } + osd->want_redraw = true; +} + +void osd_changed_all(struct osd_state *osd) +{ + for (int n = 0; n < MAX_OSD_PARTS; n++) + osd_changed(osd, n); +} + +// Scale factor to translate OSD coordinates to what the obj uses internally. +// osd_coordinates * (sh, sh) = obj_coordinates +void osd_object_get_scale_factor(struct osd_state *osd, struct osd_object *obj, + double *sw, double *sh) +{ + int nw, nh; + osd_object_get_resolution(osd, obj, &nw, &nh); + *sw = nw / (double)obj->vo_res.w; + *sh = nh / (double)obj->vo_res.h; +} |