github/mpv
1
Fork 0
mirror of https://github.com/mpv-player/mpv synced 2024-10-30 04:46:41 +01:00
Code Releases Activity
5ff065269c
mpv/libass/ass_render.c
eugeni 92efd606d1 Avoid text deformation and subtitles moving outside the screen in pan-and-scan 
mode.

For this, crop amounts are passed from vo_gl as negative margins sizes. They
are used to calculate aspect ratio. They are ignored when calculating subtitle
 positions, so subtitles will stay on screen most of the time.
Based on a patch by Jindrich Makovicka [makovick gmail com].


git-svn-id: svn://svn.mplayerhq.hu/mplayer/trunk@24815 b3059339-0415-0410-9bf9-f77b7e298cf2
2007-10-19 18:16:23 +00:00

2413 lines
70 KiB
C
Raw Blame History

// -*- c-basic-offset: 8; indent-tabs-mode: t -*-
// vim:ts=8:sw=8:noet:ai:
/*
Copyright (C) 2006 Evgeniy Stepanov <eugeni.stepanov@gmail.com>
This program 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.
This program 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 this program; if not, write to the Free Software
Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
*/
#include "config.h"
#include <assert.h>
#include <math.h>
#include <inttypes.h>
#include <ft2build.h>
#include FT_FREETYPE_H
#include FT_STROKER_H
#include FT_GLYPH_H
#include FT_SYNTHESIS_H
#include "mputils.h"
#include "ass.h"
#include "ass_font.h"
#include "ass_bitmap.h"
#include "ass_cache.h"
#include "ass_utils.h"
#include "ass_fontconfig.h"
#include "ass_library.h"
#define MAX_GLYPHS 1000
#define MAX_LINES 100
static int last_render_id = 0;
typedef struct ass_settings_s {
int frame_width;
int frame_height;
double font_size_coeff; // font size multiplier
double line_spacing; // additional line spacing (in frame pixels)
int top_margin; // height of top margin. Everything except toptitles is shifted down by top_margin.
int bottom_margin; // height of bottom margin. (frame_height - top_margin - bottom_margin) is original video height.
int left_margin;
int right_margin;
int use_margins; // 0 - place all subtitles inside original frame
// 1 - use margins for placing toptitles and subtitles
double aspect; // frame aspect ratio, d_width / d_height.
ass_hinting_t hinting;
char* default_font;
char* default_family;
} ass_settings_t;
// a rendered event
typedef struct event_images_s {
ass_image_t* imgs;
int top, height;
int detect_collisions;
int shift_direction;
ass_event_t* event;
} event_images_t;
struct ass_renderer_s {
ass_library_t* library;
FT_Library ftlibrary;
fc_instance_t* fontconfig_priv;
ass_settings_t settings;
int render_id;
ass_synth_priv_t* synth_priv;
ass_image_t* images_root; // rendering result is stored here
ass_image_t* prev_images_root;
event_images_t* eimg; // temporary buffer for sorting rendered events
int eimg_size; // allocated buffer size
};
typedef enum {EF_NONE = 0, EF_KARAOKE, EF_KARAOKE_KF, EF_KARAOKE_KO} effect_t;
// describes a glyph
// glyph_info_t and text_info_t are used for text centering and word-wrapping operations
typedef struct glyph_info_s {
unsigned symbol;
FT_Glyph glyph;
FT_Glyph outline_glyph;
bitmap_t* bm; // glyph bitmap
bitmap_t* bm_o; // outline bitmap
bitmap_t* bm_s; // shadow bitmap
FT_BBox bbox;
FT_Vector pos;
char linebreak; // the first (leading) glyph of some line ?
uint32_t c[4]; // colors
FT_Vector advance; // 26.6
effect_t effect_type;
int effect_timing; // time duration of current karaoke word
// after process_karaoke_effects: distance in pixels from the glyph origin.
// part of the glyph to the left of it is displayed in a different color.
int effect_skip_timing; // delay after the end of last karaoke word
int asc, desc; // font max ascender and descender
// int height;
int be; // blur edges
int shadow;
double frx, fry, frz; // rotation
bitmap_hash_key_t hash_key;
} glyph_info_t;
typedef struct line_info_s {
int asc, desc;
} line_info_t;
typedef struct text_info_s {
glyph_info_t* glyphs;
int length;
line_info_t lines[MAX_LINES];
int n_lines;
int height;
} text_info_t;
// Renderer state.
// Values like current font face, color, screen position, clipping and so on are stored here.
typedef struct render_context_s {
ass_event_t* event;
ass_style_t* style;
ass_font_t* font;
char* font_path;
double font_size;
FT_Stroker stroker;
int alignment; // alignment overrides go here; if zero, style value will be used
double frx, fry, frz;
enum { EVENT_NORMAL, // "normal" top-, sub- or mid- title
EVENT_POSITIONED, // happens after pos(,), margins are ignored
EVENT_HSCROLL, // "Banner" transition effect, text_width is unlimited
EVENT_VSCROLL // "Scroll up", "Scroll down" transition effects
} evt_type;
int pos_x, pos_y; // position
int org_x, org_y; // origin
char have_origin; // origin is explicitly defined; if 0, get_base_point() is used
double scale_x, scale_y;
double hspacing; // distance between letters, in pixels
double border; // outline width
uint32_t c[4]; // colors(Primary, Secondary, so on) in RGBA
int clip_x0, clip_y0, clip_x1, clip_y1;
char detect_collisions;
uint32_t fade; // alpha from \fad
char be; // blur edges
int shadow;
effect_t effect_type;
int effect_timing;
int effect_skip_timing;
enum { SCROLL_LR, // left-to-right
SCROLL_RL,
SCROLL_TB, // top-to-bottom
SCROLL_BT
} scroll_direction; // for EVENT_HSCROLL, EVENT_VSCROLL
int scroll_shift;
// face properties
char* family;
unsigned bold;
unsigned italic;
} render_context_t;
// frame-global data
typedef struct frame_context_s {
ass_renderer_t* ass_priv;
int width, height; // screen dimensions
int orig_height; // frame height ( = screen height - margins )
int orig_width; // frame width ( = screen width - margins )
int orig_height_nocrop; // frame height ( = screen height - margins + cropheight)
int orig_width_nocrop; // frame width ( = screen width - margins + cropwidth)
ass_track_t* track;
long long time; // frame's timestamp, ms
double font_scale;
double font_scale_x; // x scale applied to all glyphs to preserve text aspect ratio
double border_scale;
} frame_context_t;
static ass_renderer_t* ass_renderer;
static ass_settings_t* global_settings;
static text_info_t text_info;
static render_context_t render_context;
static frame_context_t frame_context;
struct render_priv_s {
int top, height;
int render_id;
};
static void ass_lazy_track_init(void)
{
ass_track_t* track = frame_context.track;
if (track->PlayResX && track->PlayResY)
return;
if (!track->PlayResX && !track->PlayResY) {
mp_msg(MSGT_ASS, MSGL_WARN, MSGTR_LIBASS_NeitherPlayResXNorPlayResYDefined);
track->PlayResX = 384;
track->PlayResY = 288;
} else {
double orig_aspect = (global_settings->aspect * frame_context.height * frame_context.orig_width) /
frame_context.orig_height / frame_context.width;
if (!track->PlayResY) {
track->PlayResY = track->PlayResX / orig_aspect + .5;
mp_msg(MSGT_ASS, MSGL_WARN, MSGTR_LIBASS_PlayResYUndefinedSettingY, track->PlayResY);
} else if (!track->PlayResX) {
track->PlayResX = track->PlayResY * orig_aspect + .5;
mp_msg(MSGT_ASS, MSGL_WARN, MSGTR_LIBASS_PlayResXUndefinedSettingX, track->PlayResX);
}
}
}
ass_renderer_t* ass_renderer_init(ass_library_t* library)
{
int error;
FT_Library ft;
ass_renderer_t* priv = 0;
memset(&render_context, 0, sizeof(render_context));
memset(&frame_context, 0, sizeof(frame_context));
memset(&text_info, 0, sizeof(text_info));
error = FT_Init_FreeType( &ft );
if ( error ) {
mp_msg(MSGT_ASS, MSGL_FATAL, MSGTR_LIBASS_FT_Init_FreeTypeFailed);
goto ass_init_exit;
}
priv = calloc(1, sizeof(ass_renderer_t));
if (!priv) {
FT_Done_FreeType(ft);
goto ass_init_exit;
}
priv->synth_priv = ass_synth_init();
priv->library = library;
priv->ftlibrary = ft;
// images_root and related stuff is zero-filled in calloc
ass_font_cache_init();
ass_bitmap_cache_init();
ass_glyph_cache_init();
text_info.glyphs = calloc(MAX_GLYPHS, sizeof(glyph_info_t));
ass_init_exit:
if (priv) mp_msg(MSGT_ASS, MSGL_INFO, MSGTR_LIBASS_Init);
else mp_msg(MSGT_ASS, MSGL_ERR, MSGTR_LIBASS_InitFailed);
return priv;
}
void ass_renderer_done(ass_renderer_t* priv)
{
ass_font_cache_done();
ass_bitmap_cache_done();
ass_glyph_cache_done();
if (render_context.stroker) {
FT_Stroker_Done(render_context.stroker);
render_context.stroker = 0;
}
if (priv && priv->ftlibrary) FT_Done_FreeType(priv->ftlibrary);
if (priv && priv->fontconfig_priv) fontconfig_done(priv->fontconfig_priv);
if (priv && priv->synth_priv) ass_synth_done(priv->synth_priv);
if (priv && priv->eimg) free(priv->eimg);
if (priv) free(priv);
if (text_info.glyphs) free(text_info.glyphs);
}
/**
* \brief Create a new ass_image_t
* Parameters are the same as ass_image_t fields.
*/
static ass_image_t* my_draw_bitmap(unsigned char* bitmap, int bitmap_w, int bitmap_h, int stride, int dst_x, int dst_y, uint32_t color)
{
ass_image_t* img = calloc(1, sizeof(ass_image_t));
img->w = bitmap_w;
img->h = bitmap_h;
img->stride = stride;
img->bitmap = bitmap;
img->color = color;
img->dst_x = dst_x;
img->dst_y = dst_y;
return img;
}
/**
* \brief convert bitmap glyph into ass_image_t struct(s)
* \param bit freetype bitmap glyph, FT_PIXEL_MODE_GRAY
* \param dst_x bitmap x coordinate in video frame
* \param dst_y bitmap y coordinate in video frame
* \param color first color, RGBA
* \param color2 second color, RGBA
* \param brk x coordinate relative to glyph origin, color is used to the left of brk, color2 - to the right
* \param tail pointer to the last image's next field, head of the generated list should be stored here
* \return pointer to the new list tail
* Performs clipping. Uses my_draw_bitmap for actual bitmap convertion.
*/
static ass_image_t** render_glyph(bitmap_t* bm, int dst_x, int dst_y, uint32_t color, uint32_t color2, int brk, ass_image_t** tail)
{
// brk is relative to dst_x
// color = color left of brk
// color2 = color right of brk
int b_x0, b_y0, b_x1, b_y1; // visible part of the bitmap
int clip_x0, clip_y0, clip_x1, clip_y1;
int tmp;
ass_image_t* img;
dst_x += bm->left;
dst_y += bm->top;
brk -= bm->left;
// clipping
clip_x0 = render_context.clip_x0;
clip_y0 = render_context.clip_y0;
clip_x1 = render_context.clip_x1;
clip_y1 = render_context.clip_y1;
b_x0 = 0;
b_y0 = 0;
b_x1 = bm->w;
b_y1 = bm->h;
tmp = dst_x - clip_x0;
if (tmp < 0) {
mp_msg(MSGT_ASS, MSGL_DBG2, "clip left\n");
b_x0 = - tmp;
}
tmp = dst_y - clip_y0;
if (tmp < 0) {
mp_msg(MSGT_ASS, MSGL_DBG2, "clip top\n");
b_y0 = - tmp;
}
tmp = clip_x1 - dst_x - bm->w;
if (tmp < 0) {
mp_msg(MSGT_ASS, MSGL_DBG2, "clip right\n");
b_x1 = bm->w + tmp;
}
tmp = clip_y1 - dst_y - bm->h;
if (tmp < 0) {
mp_msg(MSGT_ASS, MSGL_DBG2, "clip bottom\n");
b_y1 = bm->h + tmp;
}
if ((b_y0 >= b_y1) || (b_x0 >= b_x1))
return tail;
if (brk > b_x0) { // draw left part
if (brk > b_x1) brk = b_x1;
img = my_draw_bitmap(bm->buffer + bm->w * b_y0 + b_x0,
brk - b_x0, b_y1 - b_y0, bm->w,
dst_x + b_x0, dst_y + b_y0, color);
*tail = img;
tail = &img->next;
}
if (brk < b_x1) { // draw right part
if (brk < b_x0) brk = b_x0;
img = my_draw_bitmap(bm->buffer + bm->w * b_y0 + brk,
b_x1 - brk, b_y1 - b_y0, bm->w,
dst_x + brk, dst_y + b_y0, color2);
*tail = img;
tail = &img->next;
}
return tail;
}
/**
* \brief Convert text_info_t struct to ass_image_t list
* Splits glyphs in halves when needed (for \kf karaoke).
*/
static ass_image_t* render_text(text_info_t* text_info, int dst_x, int dst_y)
{
int pen_x, pen_y;
int i;
bitmap_t* bm;
ass_image_t* head;
ass_image_t** tail = &head;
for (i = 0; i < text_info->length; ++i) {
glyph_info_t* info = text_info->glyphs + i;
if ((info->symbol == 0) || (info->symbol == '\n') || !info->bm_s || (info->shadow == 0))
continue;
pen_x = dst_x + info->pos.x + info->shadow;
pen_y = dst_y + info->pos.y + info->shadow;
bm = info->bm_s;
tail = render_glyph(bm, pen_x, pen_y, info->c[3], 0, 1000000, tail);
}
for (i = 0; i < text_info->length; ++i) {
glyph_info_t* info = text_info->glyphs + i;
if ((info->symbol == 0) || (info->symbol == '\n') || !info->bm_o)
continue;
pen_x = dst_x + info->pos.x;
pen_y = dst_y + info->pos.y;
bm = info->bm_o;
if ((info->effect_type == EF_KARAOKE_KO) && (info->effect_timing <= info->bbox.xMax)) {
// do nothing
} else
tail = render_glyph(bm, pen_x, pen_y, info->c[2], 0, 1000000, tail);
}
for (i = 0; i < text_info->length; ++i) {
glyph_info_t* info = text_info->glyphs + i;
if ((info->symbol == 0) || (info->symbol == '\n') || !info->bm)
continue;
pen_x = dst_x + info->pos.x;
pen_y = dst_y + info->pos.y;
bm = info->bm;
if ((info->effect_type == EF_KARAOKE) || (info->effect_type == EF_KARAOKE_KO)) {
if (info->effect_timing > info->bbox.xMax)
tail = render_glyph(bm, pen_x, pen_y, info->c[0], 0, 1000000, tail);
else
tail = render_glyph(bm, pen_x, pen_y, info->c[1], 0, 1000000, tail);
} else if (info->effect_type == EF_KARAOKE_KF) {
tail = render_glyph(bm, pen_x, pen_y, info->c[0], info->c[1], info->effect_timing, tail);
} else
tail = render_glyph(bm, pen_x, pen_y, info->c[0], 0, 1000000, tail);
}
*tail = 0;
return head;
}
/**
* \brief Mapping between script and screen coordinates
*/
static int x2scr(int x) {
return x*frame_context.orig_width_nocrop / frame_context.track->PlayResX +
FFMAX(global_settings->left_margin, 0);
}
/**
* \brief Mapping between script and screen coordinates
*/
static int y2scr(int y) {
return y * frame_context.orig_height_nocrop / frame_context.track->PlayResY +
FFMAX(global_settings->top_margin, 0);
}
// the same for toptitles
static int y2scr_top(int y) {
if (global_settings->use_margins)
return y * frame_context.orig_height_nocrop / frame_context.track->PlayResY;
else
return y * frame_context.orig_height_nocrop / frame_context.track->PlayResY +
FFMAX(global_settings->top_margin, 0);
}
// the same for subtitles
static int y2scr_sub(int y) {
if (global_settings->use_margins)
return y * frame_context.orig_height_nocrop / frame_context.track->PlayResY +
FFMAX(global_settings->top_margin, 0) +
FFMAX(global_settings->bottom_margin, 0);
else
return y * frame_context.orig_height_nocrop / frame_context.track->PlayResY +
FFMAX(global_settings->top_margin, 0);
}
static void compute_string_bbox( text_info_t* info, FT_BBox *abbox ) {
FT_BBox bbox;
int i;
if (text_info.length > 0) {
bbox.xMin = 32000;
bbox.xMax = -32000;
bbox.yMin = - d6_to_int(text_info.lines[0].asc) + text_info.glyphs[0].pos.y;
bbox.yMax = d6_to_int(text_info.height - text_info.lines[0].asc) + text_info.glyphs[0].pos.y;
for (i = 0; i < text_info.length; ++i) {
int s = text_info.glyphs[i].pos.x;
int e = s + d6_to_int(text_info.glyphs[i].advance.x);
bbox.xMin = FFMIN(bbox.xMin, s);
bbox.xMax = FFMAX(bbox.xMax, e);
}
} else
bbox.xMin = bbox.xMax = bbox.yMin = bbox.yMax = 0;
/* return string bbox */
*abbox = bbox;
}
/**
* \brief Check if starting part of (*p) matches sample. If true, shift p to the first symbol after the matching part.
*/
static inline int mystrcmp(char** p, const char* sample) {
int len = strlen(sample);
if (strncmp(*p, sample, len) == 0) {
(*p) += len;
return 1;
} else
return 0;
}
static void change_font_size(double sz)
{
double size = sz * frame_context.font_scale;
if (size < 1)
size = 1;
else if (size > frame_context.height * 2)
size = frame_context.height * 2;
ass_font_set_size(render_context.font, size);
render_context.font_size = sz;
}
/**
* \brief Change current font, using setting from render_context.
*/
static void update_font(void)
{
unsigned val;
ass_renderer_t* priv = frame_context.ass_priv;
ass_font_desc_t desc;
desc.family = strdup(render_context.family);
val = render_context.bold;
// 0 = normal, 1 = bold, >1 = exact weight
if (val == 0) val = 80; // normal
else if (val == 1) val = 200; // bold
desc.bold = val;
val = render_context.italic;
if (val == 0) val = 0; // normal
else if (val == 1) val = 110; //italic
desc.italic = val;
render_context.font = ass_font_new(priv->library, priv->ftlibrary, priv->fontconfig_priv, &desc);
free(desc.family);
if (render_context.font)
change_font_size(render_context.font_size);
}
/**
* \brief Change border width
* negative value resets border to style value
*/
static void change_border(double border)
{
int b;
if (!render_context.font) return;
if (border < 0) {
if (render_context.style->BorderStyle == 1) {
if (render_context.style->Outline == 0 && render_context.style->Shadow > 0)
border = 1.;
else
border = render_context.style->Outline;
} else
border = 1.;
}
render_context.border = border;
b = 64 * border * frame_context.border_scale;
if (b > 0) {
if (!render_context.stroker) {
int error;
#if (FREETYPE_MAJOR > 2) || ((FREETYPE_MAJOR == 2) && (FREETYPE_MINOR > 1))
error = FT_Stroker_New( ass_renderer->ftlibrary, &render_context.stroker );
#else // < 2.2
error = FT_Stroker_New( render_context.font->faces[0]->memory, &render_context.stroker );
#endif
if (error) {
mp_msg(MSGT_ASS, MSGL_V, "failed to get stroker\n");
render_context.stroker = 0;
}
}
if (render_context.stroker)
FT_Stroker_Set( render_context.stroker, b,
FT_STROKER_LINECAP_ROUND,
FT_STROKER_LINEJOIN_ROUND,
0 );
} else {
FT_Stroker_Done(render_context.stroker);
render_context.stroker = 0;
}
}
#define _r(c) ((c)>>24)
#define _g(c) (((c)>>16)&0xFF)
#define _b(c) (((c)>>8)&0xFF)
#define _a(c) ((c)&0xFF)
/**
* \brief Calculate a weighted average of two colors
* calculates c1*(1-a) + c2*a, but separately for each component except alpha
*/
static void change_color(uint32_t* var, uint32_t new, double pwr)
{
(*var)= ((uint32_t)(_r(*var) * (1 - pwr) + _r(new) * pwr) << 24) +
((uint32_t)(_g(*var) * (1 - pwr) + _g(new) * pwr) << 16) +
((uint32_t)(_b(*var) * (1 - pwr) + _b(new) * pwr) << 8) +
_a(*var);
}
// like change_color, but for alpha component only
static void change_alpha(uint32_t* var, uint32_t new, double pwr)
{
*var = (_r(*var) << 24) + (_g(*var) << 16) + (_b(*var) << 8) + (_a(*var) * (1 - pwr) + _a(new) * pwr);
}
/**
* \brief Multiply two alpha values
* \param a first value
* \param b second value
* \return result of multiplication
* Parameters and result are limited by 0xFF.
*/
static uint32_t mult_alpha(uint32_t a, uint32_t b)
{
return 0xFF - (0xFF - a) * (0xFF - b) / 0xFF;
}
/**
* \brief Calculate alpha value by piecewise linear function
* Used for \fad, \fade implementation.
*/
static unsigned interpolate_alpha(long long now,
long long t1, long long t2, long long t3, long long t4,
unsigned a1, unsigned a2, unsigned a3)
{
unsigned a;
double cf;
if (now <= t1) {
a = a1;
} else if (now >= t4) {
a = a3;
} else if (now < t2) { // and > t1
cf = ((double)(now - t1)) / (t2 - t1);
a = a1 * (1 - cf) + a2 * cf;
} else if (now > t3) {
cf = ((double)(now - t3)) / (t4 - t3);
a = a2 * (1 - cf) + a3 * cf;
} else { // t2 <= now <= t3
a = a2;
}
return a;
}
static void reset_render_context(void);
/**
* \brief Parse style override tag.
* \param p string to parse
* \param pwr multiplier for some tag effects (comes from \t tags)
*/
static char* parse_tag(char* p, double pwr) {
#define skip_all(x) if (*p == (x)) ++p; else { \
while ((*p != (x)) && (*p != '}') && (*p != 0)) {++p;} }
#define skip(x) if (*p == (x)) ++p; else { return p; }
skip_all('\\');
if ((*p == '}') || (*p == 0))
return p;
if (mystrcmp(&p, "fsc")) {
char tp = *p++;
double val;
if (tp == 'x') {
if (mystrtod(&p, &val)) {
val /= 100;
render_context.scale_x = render_context.scale_x * ( 1 - pwr) + val * pwr;
} else
render_context.scale_x = render_context.style->ScaleX;
} else if (tp == 'y') {
if (mystrtod(&p, &val)) {
val /= 100;
render_context.scale_y = render_context.scale_y * ( 1 - pwr) + val * pwr;
} else
render_context.scale_y = render_context.style->ScaleY;
}
} else if (mystrcmp(&p, "fsp")) {
double val;
if (mystrtod(&p, &val))
render_context.hspacing = render_context.hspacing * ( 1 - pwr ) + val * pwr;
else
render_context.hspacing = render_context.style->Spacing;
} else if (mystrcmp(&p, "fs")) {
double val;
if (mystrtod(&p, &val))
val = render_context.font_size * ( 1 - pwr ) + val * pwr;
else
val = render_context.style->FontSize;
if (render_context.font)
change_font_size(val);
} else if (mystrcmp(&p, "bord")) {
double val;
if (mystrtod(&p, &val))
val = render_context.border * ( 1 - pwr ) + val * pwr;
else
val = -1.; // reset to default
change_border(val);
} else if (mystrcmp(&p, "move")) {
int x1, x2, y1, y2;
long long t1, t2, delta_t, t;
int x, y;
double k;
skip('(');
x1 = strtol(p, &p, 10);
skip(',');
y1 = strtol(p, &p, 10);
skip(',');
x2 = strtol(p, &p, 10);
skip(',');
y2 = strtol(p, &p, 10);
if (*p == ',') {
skip(',');
t1 = strtoll(p, &p, 10);
skip(',');
t2 = strtoll(p, &p, 10);
mp_msg(MSGT_ASS, MSGL_DBG2, "movement6: (%d, %d) -> (%d, %d), (%" PRId64 " .. %" PRId64 ")\n",
x1, y1, x2, y2, (int64_t)t1, (int64_t)t2);
} else {
t1 = 0;
t2 = render_context.event->Duration;
mp_msg(MSGT_ASS, MSGL_DBG2, "movement: (%d, %d) -> (%d, %d)\n", x1, y1, x2, y2);
}
skip(')');
delta_t = t2 - t1;
t = frame_context.time - render_context.event->Start;
if (t < t1)
k = 0.;
else if (t > t2)
k = 1.;
else k = ((double)(t - t1)) / delta_t;
x = k * (x2 - x1) + x1;
y = k * (y2 - y1) + y1;
render_context.pos_x = x;
render_context.pos_y = y;
render_context.detect_collisions = 0;
render_context.evt_type = EVENT_POSITIONED;
} else if (mystrcmp(&p, "frx")) {
double val;
if (mystrtod(&p, &val)) {
val *= M_PI / 180;
render_context.frx = val * pwr + render_context.frx * (1-pwr);
} else
render_context.frx = 0.;
} else if (mystrcmp(&p, "fry")) {
double val;
if (mystrtod(&p, &val)) {
val *= M_PI / 180;
render_context.fry = val * pwr + render_context.fry * (1-pwr);
} else
render_context.fry = 0.;
} else if (mystrcmp(&p, "frz") || mystrcmp(&p, "fr")) {
double val;
if (mystrtod(&p, &val)) {
val *= M_PI / 180;
render_context.frz = val * pwr + render_context.frz * (1-pwr);
} else
render_context.frz = M_PI * render_context.style->Angle / 180.;
} else if (mystrcmp(&p, "fn")) {
char* start = p;
char* family;
skip_all('\\');
if (p > start) {
family = malloc(p - start + 1);
strncpy(family, start, p - start);
family[p - start] = '\0';
} else
family = strdup(render_context.style->FontName);
if (render_context.family)
free(render_context.family);
render_context.family = family;
update_font();
} else if (mystrcmp(&p, "alpha")) {
uint32_t val;
int i;
if (strtocolor(&p, &val)) {
unsigned char a = val >> 24;
for (i = 0; i < 4; ++i)
change_alpha(&render_context.c[i], a, pwr);
} else {
change_alpha(&render_context.c[0], render_context.style->PrimaryColour, pwr);
change_alpha(&render_context.c[1], render_context.style->SecondaryColour, pwr);
change_alpha(&render_context.c[2], render_context.style->OutlineColour, pwr);
change_alpha(&render_context.c[3], render_context.style->BackColour, pwr);
}
// FIXME: simplify
} else if (mystrcmp(&p, "an")) {
int val;
if (mystrtoi(&p, 10, &val) && val) {
int v = (val - 1) / 3; // 0, 1 or 2 for vertical alignment
mp_msg(MSGT_ASS, MSGL_DBG2, "an %d\n", val);
if (v != 0) v = 3 - v;
val = ((val - 1) % 3) + 1; // horizontal alignment
val += v*4;
mp_msg(MSGT_ASS, MSGL_DBG2, "align %d\n", val);
render_context.alignment = val;
} else
render_context.alignment = render_context.style->Alignment;
} else if (mystrcmp(&p, "a")) {
int val;
if (mystrtoi(&p, 10, &val) && val)
render_context.alignment = val;
else
render_context.alignment = render_context.style->Alignment;
} else if (mystrcmp(&p, "pos")) {
int v1, v2;
skip('(');
v1 = strtol(p, &p, 10);
skip(',');
v2 = strtol(p, &p, 10);
skip(')');
mp_msg(MSGT_ASS, MSGL_DBG2, "pos(%d, %d)\n", v1, v2);
render_context.evt_type = EVENT_POSITIONED;
render_context.detect_collisions = 0;
render_context.pos_x = v1;
render_context.pos_y = v2;
} else if (mystrcmp(&p, "fad")) {
int a1, a2, a3;
long long t1, t2, t3, t4;
if (*p == 'e') ++p; // either \fad or \fade
skip('(');
a1 = strtol(p, &p, 10);
skip(',');
a2 = strtol(p, &p, 10);
if (*p == ')') {
// 2-argument version (\fad, according to specs)
// a1 and a2 are fade-in and fade-out durations
t1 = 0;
t4 = render_context.event->Duration;
t2 = a1;
t3 = t4 - a2;
a1 = 0xFF;
a2 = 0;
a3 = 0xFF;
} else {
// 6-argument version (\fade)
// a1 and a2 (and a3) are opacity values
skip(',');
a3 = strtol(p, &p, 10);
skip(',');
t1 = strtoll(p, &p, 10);
skip(',');
t2 = strtoll(p, &p, 10);
skip(',');
t3 = strtoll(p, &p, 10);
skip(',');
t4 = strtoll(p, &p, 10);
}
skip(')');
render_context.fade = interpolate_alpha(frame_context.time - render_context.event->Start, t1, t2, t3, t4, a1, a2, a3);
} else if (mystrcmp(&p, "org")) {
int v1, v2;
skip('(');
v1 = strtol(p, &p, 10);
skip(',');
v2 = strtol(p, &p, 10);
skip(')');
mp_msg(MSGT_ASS, MSGL_DBG2, "org(%d, %d)\n", v1, v2);
// render_context.evt_type = EVENT_POSITIONED;
render_context.org_x = v1;
render_context.org_y = v2;
render_context.have_origin = 1;
} else if (mystrcmp(&p, "t")) {
double v[3];
int v1, v2;
double v3;
int cnt;
long long t1, t2, t, delta_t;
double k;
skip('(');
for (cnt = 0; cnt < 3; ++cnt) {
if (*p == '\\')
break;
v[cnt] = strtod(p, &p);
skip(',');
}
if (cnt == 3) {
v1 = v[0]; v2 = v[1]; v3 = v[2];
} else if (cnt == 2) {
v1 = v[0]; v2 = v[1]; v3 = 1.;
} else if (cnt == 1) {
v1 = 0; v2 = render_context.event->Duration; v3 = v[0];
} else { // cnt == 0
v1 = 0; v2 = render_context.event->Duration; v3 = 1.;
}
render_context.detect_collisions = 0;
t1 = v1;
t2 = v2;
delta_t = v2 - v1;
if (v3 < 0.)
v3 = 0.;
t = frame_context.time - render_context.event->Start; // FIXME: move to render_context
if (t <= t1)
k = 0.;
else if (t >= t2)
k = 1.;
else {
assert(delta_t != 0.);
k = pow(((double)(t - t1)) / delta_t, v3);
}
while (*p == '\\')
p = parse_tag(p, k); // maybe k*pwr ? no, specs forbid nested \t's
skip_all(')'); // FIXME: better skip(')'), but much more tags support required
} else if (mystrcmp(&p, "clip")) {
int x0, y0, x1, y1;
int res = 1;
skip('(');
res &= mystrtoi(&p, 10, &x0);
skip(',');
res &= mystrtoi(&p, 10, &y0);
skip(',');
res &= mystrtoi(&p, 10, &x1);
skip(',');
res &= mystrtoi(&p, 10, &y1);
skip(')');
if (res) {
render_context.clip_x0 = render_context.clip_x0 * (1-pwr) + x0 * pwr;
render_context.clip_x1 = render_context.clip_x1 * (1-pwr) + x1 * pwr;
render_context.clip_y0 = render_context.clip_y0 * (1-pwr) + y0 * pwr;
render_context.clip_y1 = render_context.clip_y1 * (1-pwr) + y1 * pwr;
} else {
render_context.clip_x0 = 0;
render_context.clip_y0 = 0;
render_context.clip_x1 = frame_context.track->PlayResX;
render_context.clip_y1 = frame_context.track->PlayResY;
}
} else if (mystrcmp(&p, "c")) {
uint32_t val;
if (!strtocolor(&p, &val))
val = render_context.style->PrimaryColour;
mp_msg(MSGT_ASS, MSGL_DBG2, "color: %X\n", val);
change_color(&render_context.c[0], val, pwr);
} else if ((*p >= '1') && (*p <= '4') && (++p) && (mystrcmp(&p, "c") || mystrcmp(&p, "a"))) {
char n = *(p-2);
int cidx = n - '1';
char cmd = *(p-1);
uint32_t val;
assert((n >= '1') && (n <= '4'));
if (!strtocolor(&p, &val))
switch(n) {
case '1': val = render_context.style->PrimaryColour; break;
case '2': val = render_context.style->SecondaryColour; break;
case '3': val = render_context.style->OutlineColour; break;
case '4': val = render_context.style->BackColour; break;
default : val = 0; break; // impossible due to assert; avoid compilation warning
}
switch (cmd) {
case 'c': change_color(render_context.c + cidx, val, pwr); break;
case 'a': change_alpha(render_context.c + cidx, val >> 24, pwr); break;
default: mp_msg(MSGT_ASS, MSGL_WARN, MSGTR_LIBASS_BadCommand, n, cmd); break;
}
mp_msg(MSGT_ASS, MSGL_DBG2, "single c/a at %f: %c%c = %X \n", pwr, n, cmd, render_context.c[cidx]);
} else if (mystrcmp(&p, "r")) {
reset_render_context();
} else if (mystrcmp(&p, "be")) {
int val;
if (mystrtoi(&p, 10, &val))
render_context.be = val ? 1 : 0;
else
render_context.be = 0;
} else if (mystrcmp(&p, "b")) {
int b;
if (mystrtoi(&p, 10, &b)) {
if (pwr >= .5)
render_context.bold = b;
} else
render_context.bold = render_context.style->Bold;
update_font();
} else if (mystrcmp(&p, "i")) {
int i;
if (mystrtoi(&p, 10, &i)) {
if (pwr >= .5)
render_context.italic = i;
} else
render_context.italic = render_context.style->Italic;
update_font();
} else if (mystrcmp(&p, "kf") || mystrcmp(&p, "K")) {
int val = strtol(p, &p, 10);
render_context.effect_type = EF_KARAOKE_KF;
if (render_context.effect_timing)
render_context.effect_skip_timing += render_context.effect_timing;
render_context.effect_timing = val * 10;
} else if (mystrcmp(&p, "ko")) {
int val = strtol(p, &p, 10);
render_context.effect_type = EF_KARAOKE_KO;
if (render_context.effect_timing)
render_context.effect_skip_timing += render_context.effect_timing;
render_context.effect_timing = val * 10;
} else if (mystrcmp(&p, "k")) {
int val = strtol(p, &p, 10);
render_context.effect_type = EF_KARAOKE;
if (render_context.effect_timing)
render_context.effect_skip_timing += render_context.effect_timing;
render_context.effect_timing = val * 10;
} else if (mystrcmp(&p, "shad")) {
int val;
if (mystrtoi(&p, 10, &val))
render_context.shadow = val;
else
render_context.shadow = render_context.style->Shadow;
}
return p;
#undef skip
#undef skip_all
}
/**
* \brief Get next ucs4 char from string, parsing and executing style overrides
* \param str string pointer
* \return ucs4 code of the next char
* On return str points to the unparsed part of the string
*/
static unsigned get_next_char(char** str)
{
char* p = *str;
unsigned chr;
if (*p == '{') { // '\0' goes here
p++;
while (1) {
p = parse_tag(p, 1.);
if (*p == '}') { // end of tag
p++;
if (*p == '{') {
p++;
continue;
} else
break;
} else if (*p != '\\')
mp_msg(MSGT_ASS, MSGL_V, "Unable to parse: \"%s\" \n", p);
if (*p == 0)
break;
}
}
if (*p == '\t') {
++p;
*str = p;
return ' ';
}
if (*p == '\\') {
if ((*(p+1) == 'N') || ((*(p+1) == 'n') && (frame_context.track->WrapStyle == 2))) {
p += 2;
*str = p;
return '\n';
} else if (*(p+1) == 'n') {
p += 2;
*str = p;
return ' ';
}
}
chr = utf8_get_char(&p);
*str = p;
return chr;
}
static void apply_transition_effects(ass_event_t* event)
{
int v[4];
int cnt;
char* p = event->Effect;
if (!p || !*p) return;
cnt = 0;
while (cnt < 4 && (p = strchr(p, ';'))) {
v[cnt++] = atoi(++p);
}
if (strncmp(event->Effect, "Banner;", 7) == 0) {
int delay;
if (cnt < 1) {
mp_msg(MSGT_ASS, MSGL_V, "Error parsing effect: %s \n", event->Effect);
return;
}
if (cnt >= 2 && v[1] == 0) // right-to-left
render_context.scroll_direction = SCROLL_RL;
else // left-to-right
render_context.scroll_direction = SCROLL_LR;
delay = v[0];
if (delay == 0) delay = 1; // ?
render_context.scroll_shift = (frame_context.time - render_context.event->Start) / delay;
render_context.evt_type = EVENT_HSCROLL;
return;
}
if (strncmp(event->Effect, "Scroll up;", 10) == 0) {
render_context.scroll_direction = SCROLL_BT;
} else if (strncmp(event->Effect, "Scroll down;", 12) == 0) {
render_context.scroll_direction = SCROLL_TB;
} else {
mp_msg(MSGT_ASS, MSGL_V, "Unknown transition effect: %s \n", event->Effect);
return;
}
// parse scroll up/down parameters
{
int delay;
int y0, y1;
if (cnt < 3) {
mp_msg(MSGT_ASS, MSGL_V, "Error parsing effect: %s \n", event->Effect);
return;
}
delay = v[2];
if (delay == 0) delay = 1; // ?
render_context.scroll_shift = (frame_context.time - render_context.event->Start) / delay;
if (v[0] < v[1]) {
y0 = v[0]; y1 = v[1];
} else {
y0 = v[1]; y1 = v[0];
}
if (y1 == 0)
y1 = frame_context.track->PlayResY; // y0=y1=0 means fullscreen scrolling
render_context.clip_y0 = y0;
render_context.clip_y1 = y1;
render_context.evt_type = EVENT_VSCROLL;
render_context.detect_collisions = 0;
}
}
/**
* \brief partially reset render_context to style values
* Works like {\r}: resets some style overrides
*/
static void reset_render_context(void)
{
render_context.c[0] = render_context.style->PrimaryColour;
render_context.c[1] = render_context.style->SecondaryColour;
render_context.c[2] = render_context.style->OutlineColour;
render_context.c[3] = render_context.style->BackColour;
render_context.font_size = render_context.style->FontSize;
if (render_context.family)
free(render_context.family);
render_context.family = strdup(render_context.style->FontName);
render_context.bold = render_context.style->Bold;
render_context.italic = render_context.style->Italic;
update_font();
change_border(-1.);
render_context.scale_x = render_context.style->ScaleX;
render_context.scale_y = render_context.style->ScaleY;
render_context.hspacing = render_context.style->Spacing;
render_context.be = 0;
render_context.shadow = render_context.style->Shadow;
render_context.frx = render_context.fry = 0.;
render_context.frz = M_PI * render_context.style->Angle / 180.;
// FIXME: does not reset unsupported attributes.
}
/**
* \brief Start new event. Reset render_context.
*/
static void init_render_context(ass_event_t* event)
{
render_context.event = event;
render_context.style = frame_context.track->styles + event->Style;
reset_render_context();
render_context.evt_type = EVENT_NORMAL;
render_context.alignment = render_context.style->Alignment;
render_context.pos_x = 0;
render_context.pos_y = 0;
render_context.org_x = 0;
render_context.org_y = 0;
render_context.have_origin = 0;
render_context.clip_x0 = 0;
render_context.clip_y0 = 0;
render_context.clip_x1 = frame_context.track->PlayResX;
render_context.clip_y1 = frame_context.track->PlayResY;
render_context.detect_collisions = 1;
render_context.fade = 0;
render_context.effect_type = EF_NONE;
render_context.effect_timing = 0;
render_context.effect_skip_timing = 0;
apply_transition_effects(event);
}
static void free_render_context(void)
{
}
/**
* \brief Get normal and outline (border) glyphs
* \param symbol ucs4 char
* \param info out: struct filled with extracted data
* \param advance subpixel shift vector used for cache lookup
* Tries to get both glyphs from cache.
* If they can't be found, gets a glyph from font face, generates outline with FT_Stroker,
* and add them to cache.
* The glyphs are returned in info->glyph and info->outline_glyph
*/
static void get_outline_glyph(int symbol, glyph_info_t* info, FT_Vector* advance)
{
int error;
glyph_hash_val_t* val;
glyph_hash_key_t key;
key.font = render_context.font;
key.size = render_context.font_size;
key.ch = symbol;
key.scale_x = (render_context.scale_x * 0xFFFF);
key.scale_y = (render_context.scale_y * 0xFFFF);
key.advance = *advance;
key.bold = render_context.bold;
key.italic = render_context.italic;
key.outline = render_context.border * 0xFFFF;
info->glyph = info->outline_glyph = 0;
val = cache_find_glyph(&key);
if (val) {
FT_Glyph_Copy(val->glyph, &info->glyph);
if (val->outline_glyph)
FT_Glyph_Copy(val->outline_glyph, &info->outline_glyph);
info->bbox = val->bbox_scaled;
info->advance.x = val->advance.x;
info->advance.y = val->advance.y;
} else {
glyph_hash_val_t v;
info->glyph = ass_font_get_glyph(frame_context.ass_priv->fontconfig_priv, render_context.font, symbol, global_settings->hinting);
if (!info->glyph)
return;
info->advance.x = d16_to_d6(info->glyph->advance.x);
info->advance.y = d16_to_d6(info->glyph->advance.y);
FT_Glyph_Get_CBox( info->glyph, FT_GLYPH_BBOX_PIXELS, &info->bbox);
if (render_context.stroker) {
info->outline_glyph = info->glyph;
error = FT_Glyph_StrokeBorder( &(info->outline_glyph), render_context.stroker, 0 , 0 ); // don't destroy original
if (error) {
mp_msg(MSGT_ASS, MSGL_WARN, MSGTR_LIBASS_FT_Glyph_Stroke_Error, error);
}
}
memset(&v, 0, sizeof(v));
FT_Glyph_Copy(info->glyph, &v.glyph);
if (info->outline_glyph)
FT_Glyph_Copy(info->outline_glyph, &v.outline_glyph);
v.advance = info->advance;
v.bbox_scaled = info->bbox;
cache_add_glyph(&key, &v);
}
}
static void transform_3d(FT_Vector shift, FT_Glyph* glyph, FT_Glyph* glyph2, double frx, double fry, double frz);
/**
* \brief Get bitmaps for a glyph
* \param info glyph info
* Tries to get glyph bitmaps from bitmap cache.
* If they can't be found, they are generated by rotating and rendering the glyph.
* After that, bitmaps are added to the cache.
* They are returned in info->bm (glyph), info->bm_o (outline) and info->bm_s (shadow).
*/
static void get_bitmap_glyph(glyph_info_t* info)
{
bitmap_hash_val_t* val;
bitmap_hash_key_t* key = &info->hash_key;
val = cache_find_bitmap(key);
/* val = 0; */
if (val) {
info->bm = val->bm;
info->bm_o = val->bm_o;
info->bm_s = val->bm_s;
} else {
FT_Vector shift;
bitmap_hash_val_t hash_val;
int error;
info->bm = info->bm_o = info->bm_s = 0;
if (info->glyph && info->symbol != '\n' && info->symbol != 0) {
// calculating rotation shift vector (from rotation origin to the glyph basepoint)
shift.x = int_to_d6(info->hash_key.shift_x);
shift.y = int_to_d6(info->hash_key.shift_y);
// apply rotation
transform_3d(shift, &info->glyph, &info->outline_glyph, info->frx, info->fry, info->frz);
// render glyph
error = glyph_to_bitmap(ass_renderer->synth_priv,
info->glyph, info->outline_glyph,
&info->bm, &info->bm_o,
&info->bm_s, info->be);
if (error)
info->symbol = 0;
// add bitmaps to cache
hash_val.bm_o = info->bm_o;
hash_val.bm = info->bm;
hash_val.bm_s = info->bm_s;
cache_add_bitmap(&(info->hash_key), &hash_val);
}
}
// deallocate glyphs
if (info->glyph)
FT_Done_Glyph(info->glyph);
if (info->outline_glyph)
FT_Done_Glyph(info->outline_glyph);
}
/**
* This function goes through text_info and calculates text parameters.
* The following text_info fields are filled:
* height
* lines[].height
* lines[].asc
* lines[].desc
*/
static void measure_text(void)
{
int cur_line = 0, max_asc = 0, max_desc = 0;
int i;
text_info.height = 0;
for (i = 0; i < text_info.length + 1; ++i) {
if ((i == text_info.length) || text_info.glyphs[i].linebreak) {
text_info.lines[cur_line].asc = max_asc;
text_info.lines[cur_line].desc = max_desc;
text_info.height += max_asc + max_desc;
cur_line ++;
max_asc = max_desc = 0;
}
if (i < text_info.length) {
glyph_info_t* cur = text_info.glyphs + i;
if (cur->asc > max_asc)
max_asc = cur->asc;
if (cur->desc > max_desc)
max_desc = cur->desc;
}
}
text_info.height += (text_info.n_lines - 1) * double_to_d6(global_settings->line_spacing);
}
/**
* \brief rearrange text between lines
* \param max_text_width maximal text line width in pixels
* The algo is similar to the one in libvo/sub.c:
* 1. Place text, wrapping it when current line is full
* 2. Try moving words from the end of a line to the beginning of the next one while it reduces
* the difference in lengths between this two lines.
* The result may not be optimal, but usually is good enough.
*/
static void wrap_lines_smart(int max_text_width)
{
int i, j;
glyph_info_t *cur, *s1, *e1, *s2, *s3, *w;
int last_space;
int break_type;
int exit;
int pen_shift_x;
int pen_shift_y;
int cur_line;
last_space = -1;
text_info.n_lines = 1;
break_type = 0;
s1 = text_info.glyphs; // current line start
for (i = 0; i < text_info.length; ++i) {
int break_at, s_offset, len;
cur = text_info.glyphs + i;
break_at = -1;
s_offset = s1->bbox.xMin + s1->pos.x;
len = (cur->bbox.xMax + cur->pos.x) - s_offset;
if (cur->symbol == '\n') {
break_type = 2;
break_at = i;
mp_msg(MSGT_ASS, MSGL_DBG2, "forced line break at %d\n", break_at);
}
if (len >= max_text_width) {
break_type = 1;
break_at = last_space;
if (break_at == -1)
break_at = i - 1;
if (break_at == -1)
break_at = 0;
mp_msg(MSGT_ASS, MSGL_DBG2, "overfill at %d\n", i);
mp_msg(MSGT_ASS, MSGL_DBG2, "line break at %d\n", break_at);
}
if (break_at != -1) {
// need to use one more line
// marking break_at+1 as start of a new line
int lead = break_at + 1; // the first symbol of the new line
if (text_info.n_lines >= MAX_LINES) {
// to many lines !
// no more linebreaks
for (j = lead; j < text_info.length; ++j)
text_info.glyphs[j].linebreak = 0;
break;
}
if (lead < text_info.length)
text_info.glyphs[lead].linebreak = break_type;
last_space = -1;
s1 = text_info.glyphs + lead;
s_offset = s1->bbox.xMin + s1->pos.x;
text_info.n_lines ++;
}
if (cur->symbol == ' ')
last_space = i;
// make sure the hard linebreak is not forgotten when
// there was a new soft linebreak just inserted
if (cur->symbol == '\n' && break_type == 1)
i--;
}
#define DIFF(x,y) (((x) < (y)) ? (y - x) : (x - y))
exit = 0;
while (!exit) {
exit = 1;
w = s3 = text_info.glyphs;
s1 = s2 = 0;
for (i = 0; i <= text_info.length; ++i) {
cur = text_info.glyphs + i;
if ((i == text_info.length) || cur->linebreak) {
s1 = s2;
s2 = s3;
s3 = cur;
if (s1 && (s2->linebreak == 1)) { // have at least 2 lines, and linebreak is 'soft'
int l1, l2, l1_new, l2_new;
w = s2;
do { --w; } while ((w > s1) && (w->symbol == ' '));
while ((w > s1) && (w->symbol != ' ')) { --w; }
e1 = w;
while ((e1 > s1) && (e1->symbol == ' ')) { --e1; }
if (w->symbol == ' ') ++w;
l1 = ((s2-1)->bbox.xMax + (s2-1)->pos.x) - (s1->bbox.xMin + s1->pos.x);
l2 = ((s3-1)->bbox.xMax + (s3-1)->pos.x) - (s2->bbox.xMin + s2->pos.x);
l1_new = (e1->bbox.xMax + e1->pos.x) - (s1->bbox.xMin + s1->pos.x);
l2_new = ((s3-1)->bbox.xMax + (s3-1)->pos.x) - (w->bbox.xMin + w->pos.x);
if (DIFF(l1_new, l2_new) < DIFF(l1, l2)) {
w->linebreak = 1;
s2->linebreak = 0;
exit = 0;
}
}
}
if (i == text_info.length)
break;
}
}
assert(text_info.n_lines >= 1);
#undef DIFF
measure_text();
pen_shift_x = 0;
pen_shift_y = 0;
cur_line = 1;
for (i = 0; i < text_info.length; ++i) {
cur = text_info.glyphs + i;
if (cur->linebreak) {
int height = text_info.lines[cur_line - 1].desc + text_info.lines[cur_line].asc;
cur_line ++;
pen_shift_x = - cur->pos.x;
pen_shift_y += d6_to_int(height + double_to_d6(global_settings->line_spacing));
mp_msg(MSGT_ASS, MSGL_DBG2, "shifting from %d to %d by (%d, %d)\n", i, text_info.length - 1, pen_shift_x, pen_shift_y);
}
cur->pos.x += pen_shift_x;
cur->pos.y += pen_shift_y;
}
}
/**
* \brief determine karaoke effects
* Karaoke effects cannot be calculated during parse stage (get_next_char()),
* so they are done in a separate step.
* Parse stage: when karaoke style override is found, its parameters are stored in the next glyph's
* (the first glyph of the karaoke word)'s effect_type and effect_timing.
* This function:
* 1. sets effect_type for all glyphs in the word (_karaoke_ word)
* 2. sets effect_timing for all glyphs to x coordinate of the border line between the left and right karaoke parts
* (left part is filled with PrimaryColour, right one - with SecondaryColour).
*/
static void process_karaoke_effects(void)
{
glyph_info_t *cur, *cur2;
glyph_info_t *s1, *e1; // start and end of the current word
glyph_info_t *s2; // start of the next word
int i;
int timing; // current timing
int tm_start, tm_end; // timings at start and end of the current word
int tm_current;
double dt;
int x;
int x_start, x_end;
tm_current = frame_context.time - render_context.event->Start;
timing = 0;
s1 = s2 = 0;
for (i = 0; i <= text_info.length; ++i) {
cur = text_info.glyphs + i;
if ((i == text_info.length) || (cur->effect_type != EF_NONE)) {
s1 = s2;
s2 = cur;
if (s1) {
e1 = s2 - 1;
tm_start = timing + s1->effect_skip_timing;
tm_end = tm_start + s1->effect_timing;
timing = tm_end;
x_start = 1000000;
x_end = -1000000;
for (cur2 = s1; cur2 <= e1; ++cur2) {
x_start = FFMIN(x_start, cur2->bbox.xMin + cur2->pos.x);
x_end = FFMAX(x_end, cur2->bbox.xMax + cur2->pos.x);
}
dt = (tm_current - tm_start);
if ((s1->effect_type == EF_KARAOKE) || (s1->effect_type == EF_KARAOKE_KO)) {
if (dt > 0)
x = x_end + 1;
else
x = x_start;
} else if (s1->effect_type == EF_KARAOKE_KF) {
dt /= (tm_end - tm_start);
x = x_start + (x_end - x_start) * dt;
} else {
mp_msg(MSGT_ASS, MSGL_ERR, MSGTR_LIBASS_UnknownEffectType_InternalError);
continue;
}
for (cur2 = s1; cur2 <= e1; ++cur2) {
cur2->effect_type = s1->effect_type;
cur2->effect_timing = x - cur2->pos.x;
}
}
}
}
}
/**
* \brief Calculate base point for positioning and rotation
* \param bbox text bbox
* \param alignment alignment
* \param bx, by out: base point coordinates
*/
static void get_base_point(FT_BBox bbox, int alignment, int* bx, int* by)
{
const int halign = alignment & 3;
const int valign = alignment & 12;
if (bx)
switch(halign) {
case HALIGN_LEFT:
*bx = bbox.xMin;
break;
case HALIGN_CENTER:
*bx = (bbox.xMax + bbox.xMin) / 2;
break;
case HALIGN_RIGHT:
*bx = bbox.xMax;
break;
}
if (by)
switch(valign) {
case VALIGN_TOP:
*by = bbox.yMin;
break;
case VALIGN_CENTER:
*by = (bbox.yMax + bbox.yMin) / 2;
break;
case VALIGN_SUB:
*by = bbox.yMax;
break;
}
}
/**
* \brief Multiply 4-vector by 4-matrix
* \param a 4-vector
* \param m 4-matrix]
* \param b out: 4-vector
* Calculates a * m and stores result in b
*/
static inline void transform_point_3d(double *a, double *m, double *b)
{
b[0] = a[0] * m[0] + a[1] * m[4] + a[2] * m[8] + a[3] * m[12];
b[1] = a[0] * m[1] + a[1] * m[5] + a[2] * m[9] + a[3] * m[13];
b[2] = a[0] * m[2] + a[1] * m[6] + a[2] * m[10] + a[3] * m[14];
b[3] = a[0] * m[3] + a[1] * m[7] + a[2] * m[11] + a[3] * m[15];
}
/**
* \brief Apply 3d transformation to a vector
* \param v FreeType vector (2d)
* \param m 4-matrix
* Transforms v by m, projects the result back to the screen plane
* Result is returned in v.
*/
static inline void transform_vector_3d(FT_Vector* v, double *m) {
const double camera = 2500 * frame_context.border_scale; // camera distance
double a[4], b[4];
a[0] = d6_to_double(v->x);
a[1] = d6_to_double(v->y);
a[2] = 0.;
a[3] = 1.;
transform_point_3d(a, m, b);
/* Apply perspective projection with the following matrix:
2500 0 0 0
0 2500 0 0
0 0 0 0
0 0 8 2500
where 2500 is camera distance, 8 - z-axis scale.
Camera is always located in (org_x, org_y, -2500). This means
that different subtitle events can be displayed at the same time
using different cameras. */
b[0] *= camera;
b[1] *= camera;
b[3] = 8 * b[2] + camera;
if (b[3] < 0.001 && b[3] > -0.001)
b[3] = b[3] < 0. ? -0.001 : 0.001;
v->x = double_to_d6(b[0] / b[3]);
v->y = double_to_d6(b[1] / b[3]);
}
/**
* \brief Apply 3d transformation to a glyph
* \param glyph FreeType glyph
* \param m 4-matrix
* Transforms glyph by m, projects the result back to the screen plane
* Result is returned in glyph.
*/
static inline void transform_glyph_3d(FT_Glyph glyph, double *m, FT_Vector shift) {
int i;
FT_Outline* outline = &((FT_OutlineGlyph)glyph)->outline;
FT_Vector* p = outline->points;
for (i=0; i<outline->n_points; i++) {
p[i].x += shift.x;
p[i].y += shift.y;
transform_vector_3d(p + i, m);
p[i].x -= shift.x;
p[i].y -= shift.y;
}
//transform_vector_3d(&glyph->advance, m);
}
/**
* \brief Apply 3d transformation to several objects
* \param shift FreeType vector
* \param glyph FreeType glyph
* \param glyph2 FreeType glyph
* \param frx x-axis rotation angle
* \param fry y-axis rotation angle
* \param frz z-axis rotation angle
* Rotates both glyphs by frx, fry and frz. Shift vector is added before rotation and subtracted after it.
*/
static void transform_3d(FT_Vector shift, FT_Glyph* glyph, FT_Glyph* glyph2, double frx, double fry, double frz)
{
fry = - fry; // FreeType's y axis goes in the opposite direction
if (frx != 0. || fry != 0. || frz != 0.) {
double m[16];
double sx = sin(frx);
double sy = sin(fry);
double sz = sin(frz);
double cx = cos(frx);
double cy = cos(fry);
double cz = cos(frz);
m[0] = cy * cz; m[1] = cy*sz; m[2] = -sy; m[3] = 0.0;
m[4] = -cx*sz + sx*sy*cz; m[5] = cx*cz + sx*sy*sz; m[6] = sx*cy; m[7] = 0.0;
m[8] = sx*sz + cx*sy*cz; m[9] = -sx*cz + cx*sy*sz; m[10] = cx*cy; m[11] = 0.0;
m[12] = 0.0; m[13] = 0.0; m[14] = 0.0; m[15] = 1.0;
if (glyph && *glyph)
transform_glyph_3d(*glyph, m, shift);
if (glyph2 && *glyph2)
transform_glyph_3d(*glyph2, m, shift);
}
}
/**
* \brief Main ass rendering function, glues everything together
* \param event event to render
* Process event, appending resulting ass_image_t's to images_root.
*/
static int ass_render_event(ass_event_t* event, event_images_t* event_images)
{
char* p;
FT_UInt previous;
FT_UInt num_glyphs;
FT_Vector pen;
unsigned code;
FT_BBox bbox;
int i, j;
FT_Vector shift;
int MarginL, MarginR, MarginV;
int last_break;
int alignment, halign, valign;
int device_x = 0, device_y = 0;
if (event->Style >= frame_context.track->n_styles) {
mp_msg(MSGT_ASS, MSGL_WARN, MSGTR_LIBASS_NoStyleFound);
return 1;
}
if (!event->Text) {
mp_msg(MSGT_ASS, MSGL_WARN, MSGTR_LIBASS_EmptyEvent);
return 1;
}
init_render_context(event);
text_info.length = 0;
pen.x = 0;
pen.y = 0;
previous = 0;
num_glyphs = 0;
p = event->Text;
// Event parsing.
while (1) {
// get next char, executing style override
// this affects render_context
code = get_next_char(&p);
// face could have been changed in get_next_char
if (!render_context.font) {
free_render_context();
return 1;
}
if (code == 0)
break;
if (text_info.length >= MAX_GLYPHS) {
mp_msg(MSGT_ASS, MSGL_WARN, MSGTR_LIBASS_MAX_GLYPHS_Reached,
(int)(event - frame_context.track->events), event->Start, event->Duration, event->Text);
break;
}
if ( previous && code ) {
FT_Vector delta;
delta = ass_font_get_kerning(render_context.font, previous, code);
pen.x += delta.x * render_context.scale_x;
pen.y += delta.y * render_context.scale_y;
}
shift.x = pen.x & 63;
shift.y = pen.y & 63;
ass_font_set_transform(render_context.font,
render_context.scale_x * frame_context.font_scale_x,
render_context.scale_y,
&shift );
get_outline_glyph(code, text_info.glyphs + text_info.length, &shift);
text_info.glyphs[text_info.length].pos.x = pen.x >> 6;
text_info.glyphs[text_info.length].pos.y = pen.y >> 6;
pen.x += text_info.glyphs[text_info.length].advance.x;
pen.x += double_to_d6(render_context.hspacing);
pen.y += text_info.glyphs[text_info.length].advance.y;
previous = code;
text_info.glyphs[text_info.length].symbol = code;
text_info.glyphs[text_info.length].linebreak = 0;
for (i = 0; i < 4; ++i) {
uint32_t clr = render_context.c[i];
change_alpha(&clr, mult_alpha(_a(clr), render_context.fade), 1.);
text_info.glyphs[text_info.length].c[i] = clr;
}
text_info.glyphs[text_info.length].effect_type = render_context.effect_type;
text_info.glyphs[text_info.length].effect_timing = render_context.effect_timing;
text_info.glyphs[text_info.length].effect_skip_timing = render_context.effect_skip_timing;
text_info.glyphs[text_info.length].be = render_context.be;
text_info.glyphs[text_info.length].shadow = render_context.shadow;
text_info.glyphs[text_info.length].frx = render_context.frx;
text_info.glyphs[text_info.length].fry = render_context.fry;
text_info.glyphs[text_info.length].frz = render_context.frz;
ass_font_get_asc_desc(render_context.font, code,
&text_info.glyphs[text_info.length].asc,
&text_info.glyphs[text_info.length].desc);
text_info.glyphs[text_info.length].asc *= render_context.scale_y;
text_info.glyphs[text_info.length].desc *= render_context.scale_y;
// fill bitmap_hash_key
text_info.glyphs[text_info.length].hash_key.font = render_context.font;
text_info.glyphs[text_info.length].hash_key.size = render_context.font_size;
text_info.glyphs[text_info.length].hash_key.outline = render_context.border * 0xFFFF;
text_info.glyphs[text_info.length].hash_key.scale_x = render_context.scale_x * 0xFFFF;
text_info.glyphs[text_info.length].hash_key.scale_y = render_context.scale_y * 0xFFFF;
text_info.glyphs[text_info.length].hash_key.frx = render_context.frx * 0xFFFF;
text_info.glyphs[text_info.length].hash_key.fry = render_context.fry * 0xFFFF;
text_info.glyphs[text_info.length].hash_key.frz = render_context.frz * 0xFFFF;
text_info.glyphs[text_info.length].hash_key.bold = render_context.bold;
text_info.glyphs[text_info.length].hash_key.italic = render_context.italic;
text_info.glyphs[text_info.length].hash_key.ch = code;
text_info.glyphs[text_info.length].hash_key.advance = shift;
text_info.glyphs[text_info.length].hash_key.be = render_context.be;
text_info.length++;
render_context.effect_type = EF_NONE;
render_context.effect_timing = 0;
render_context.effect_skip_timing = 0;
}
if (text_info.length == 0) {
// no valid symbols in the event; this can be smth like {comment}
free_render_context();
return 1;
}
// depends on glyph x coordinates being monotonous, so it should be done before line wrap
process_karaoke_effects();
// alignments
alignment = render_context.alignment;
halign = alignment & 3;
valign = alignment & 12;
MarginL = (event->MarginL) ? event->MarginL : render_context.style->MarginL;
MarginR = (event->MarginR) ? event->MarginR : render_context.style->MarginR;
MarginV = (event->MarginV) ? event->MarginV : render_context.style->MarginV;
if (render_context.evt_type != EVENT_HSCROLL) {
int max_text_width;
// calculate max length of a line
max_text_width = x2scr(frame_context.track->PlayResX - MarginR) - x2scr(MarginL);
// rearrange text in several lines
wrap_lines_smart(max_text_width);
// align text
last_break = -1;
for (i = 1; i < text_info.length + 1; ++i) { // (text_info.length + 1) is the end of the last line
if ((i == text_info.length) || text_info.glyphs[i].linebreak) {
int width, shift = 0;
glyph_info_t* first_glyph = text_info.glyphs + last_break + 1;
glyph_info_t* last_glyph = text_info.glyphs + i - 1;
while ((last_glyph > first_glyph) && ((last_glyph->symbol == '\n') || (last_glyph->symbol == 0)))
last_glyph --;
width = last_glyph->pos.x + d6_to_int(last_glyph->advance.x) - first_glyph->pos.x;
if (halign == HALIGN_LEFT) { // left aligned, no action
shift = 0;
} else if (halign == HALIGN_RIGHT) { // right aligned
shift = max_text_width - width;
} else if (halign == HALIGN_CENTER) { // centered
shift = (max_text_width - width) / 2;
}
for (j = last_break + 1; j < i; ++j) {
text_info.glyphs[j].pos.x += shift;
}
last_break = i - 1;
}
}
} else { // render_context.evt_type == EVENT_HSCROLL
measure_text();
}
// determing text bounding box
compute_string_bbox(&text_info, &bbox);
// determine device coordinates for text
// x coordinate for everything except positioned events
if (render_context.evt_type == EVENT_NORMAL ||
render_context.evt_type == EVENT_VSCROLL) {
device_x = x2scr(MarginL);
} else if (render_context.evt_type == EVENT_HSCROLL) {
if (render_context.scroll_direction == SCROLL_RL)
device_x = x2scr(frame_context.track->PlayResX - render_context.scroll_shift);
else if (render_context.scroll_direction == SCROLL_LR)
device_x = x2scr(render_context.scroll_shift) - (bbox.xMax - bbox.xMin);
}
// y coordinate for everything except positioned events
if (render_context.evt_type == EVENT_NORMAL ||
render_context.evt_type == EVENT_HSCROLL) {
if (valign == VALIGN_TOP) { // toptitle
device_y = y2scr_top(MarginV) + d6_to_int(text_info.lines[0].asc);
} else if (valign == VALIGN_CENTER) { // midtitle
int scr_y = y2scr(frame_context.track->PlayResY / 2);
device_y = scr_y - (bbox.yMax - bbox.yMin) / 2;
} else { // subtitle
int scr_y;
if (valign != VALIGN_SUB)
mp_msg(MSGT_ASS, MSGL_V, "Invalid valign, supposing 0 (subtitle)\n");
scr_y = y2scr_sub(frame_context.track->PlayResY - MarginV);
device_y = scr_y;
device_y -= d6_to_int(text_info.height);
device_y += d6_to_int(text_info.lines[0].asc);
}
} else if (render_context.evt_type == EVENT_VSCROLL) {
if (render_context.scroll_direction == SCROLL_TB)
device_y = y2scr(render_context.clip_y0 + render_context.scroll_shift) - (bbox.yMax - bbox.yMin);
else if (render_context.scroll_direction == SCROLL_BT)
device_y = y2scr(render_context.clip_y1 - render_context.scroll_shift);
}
// positioned events are totally different
if (render_context.evt_type == EVENT_POSITIONED) {
int base_x = 0;
int base_y = 0;
mp_msg(MSGT_ASS, MSGL_DBG2, "positioned event at %d, %d\n", render_context.pos_x, render_context.pos_y);
get_base_point(bbox, alignment, &base_x, &base_y);
device_x = x2scr(render_context.pos_x) - base_x;
device_y = y2scr(render_context.pos_y) - base_y;
}
// fix clip coordinates (they depend on alignment)
render_context.clip_x0 = x2scr(render_context.clip_x0);
render_context.clip_x1 = x2scr(render_context.clip_x1);
if (render_context.evt_type == EVENT_NORMAL ||
render_context.evt_type == EVENT_HSCROLL ||
render_context.evt_type == EVENT_VSCROLL) {
if (valign == VALIGN_TOP) {
render_context.clip_y0 = y2scr_top(render_context.clip_y0);
render_context.clip_y1 = y2scr_top(render_context.clip_y1);
} else if (valign == VALIGN_CENTER) {
render_context.clip_y0 = y2scr(render_context.clip_y0);
render_context.clip_y1 = y2scr(render_context.clip_y1);
} else if (valign == VALIGN_SUB) {
render_context.clip_y0 = y2scr_sub(render_context.clip_y0);
render_context.clip_y1 = y2scr_sub(render_context.clip_y1);
}
} else if (render_context.evt_type == EVENT_POSITIONED) {
render_context.clip_y0 = y2scr(render_context.clip_y0);
render_context.clip_y1 = y2scr(render_context.clip_y1);
}
// calculate rotation parameters
{
FT_Vector center;
if (render_context.have_origin) {
center.x = x2scr(render_context.org_x);
center.y = y2scr(render_context.org_y);
} else {
int bx, by;
get_base_point(bbox, alignment, &bx, &by);
center.x = device_x + bx;
center.y = device_y + by;
}
for (i = 0; i < text_info.length; ++i) {
glyph_info_t* info = text_info.glyphs + i;
if (info->hash_key.frx || info->hash_key.fry || info->hash_key.frz) {
info->hash_key.shift_x = info->pos.x + device_x - center.x;
info->hash_key.shift_y = - (info->pos.y + device_y - center.y);
} else {
info->hash_key.shift_x = 0;
info->hash_key.shift_y = 0;
}
}
}
// convert glyphs to bitmaps
for (i = 0; i < text_info.length; ++i)
get_bitmap_glyph(text_info.glyphs + i);
event_images->top = device_y - d6_to_int(text_info.lines[0].asc);
event_images->height = d6_to_int(text_info.height);
event_images->detect_collisions = render_context.detect_collisions;
event_images->shift_direction = (valign == VALIGN_TOP) ? 1 : -1;
event_images->event = event;
event_images->imgs = render_text(&text_info, device_x, device_y);
free_render_context();
return 0;
}
/**
* \brief deallocate image list
* \param img list pointer
*/
void ass_free_images(ass_image_t* img)
{
while (img) {
ass_image_t* next = img->next;
free(img);
img = next;
}
}
static void ass_reconfigure(ass_renderer_t* priv)
{
priv->render_id = ++last_render_id;
ass_glyph_cache_reset();
ass_bitmap_cache_reset();
ass_free_images(priv->prev_images_root);
priv->prev_images_root = 0;
}
void ass_set_frame_size(ass_renderer_t* priv, int w, int h)
{
if (priv->settings.frame_width != w || priv->settings.frame_height != h) {
priv->settings.frame_width = w;
priv->settings.frame_height = h;
if (priv->settings.aspect == 0.)
priv->settings.aspect = ((double)w) / h;
ass_reconfigure(priv);
}
}
void ass_set_margins(ass_renderer_t* priv, int t, int b, int l, int r)
{
if (priv->settings.left_margin != l ||
priv->settings.right_margin != r ||
priv->settings.top_margin != t ||
priv->settings.bottom_margin != b) {
priv->settings.left_margin = l;
priv->settings.right_margin = r;
priv->settings.top_margin = t;
priv->settings.bottom_margin = b;
ass_reconfigure(priv);
}
}
void ass_set_use_margins(ass_renderer_t* priv, int use)
{
priv->settings.use_margins = use;
}
void ass_set_aspect_ratio(ass_renderer_t* priv, double ar)
{
if (priv->settings.aspect != ar) {
priv->settings.aspect = ar;
ass_reconfigure(priv);
}
}
void ass_set_font_scale(ass_renderer_t* priv, double font_scale)
{
if (priv->settings.font_size_coeff != font_scale) {
priv->settings.font_size_coeff = font_scale;
ass_reconfigure(priv);
}
}
void ass_set_hinting(ass_renderer_t* priv, ass_hinting_t ht)
{
if (priv->settings.hinting != ht) {
priv->settings.hinting = ht;
ass_reconfigure(priv);
}
}
void ass_set_line_spacing(ass_renderer_t* priv, double line_spacing)
{
priv->settings.line_spacing = line_spacing;
}
int ass_set_fonts(ass_renderer_t* priv, const char* default_font, const char* default_family)
{
if (priv->settings.default_font)
free(priv->settings.default_font);
if (priv->settings.default_family)
free(priv->settings.default_family);
priv->settings.default_font = default_font ? strdup(default_font) : 0;
priv->settings.default_family = default_family ? strdup(default_family) : 0;
if (priv->fontconfig_priv)
fontconfig_done(priv->fontconfig_priv);
priv->fontconfig_priv = fontconfig_init(priv->library, priv->ftlibrary, default_family, default_font);
return !!priv->fontconfig_priv;
}
/**
* \brief Start a new frame
*/
static int ass_start_frame(ass_renderer_t *priv, ass_track_t* track, long long now)
{
ass_renderer = priv;
global_settings = &priv->settings;
if (!priv->settings.frame_width && !priv->settings.frame_height)
return 1; // library not initialized
frame_context.ass_priv = priv;
frame_context.width = global_settings->frame_width;
frame_context.height = global_settings->frame_height;
frame_context.orig_width = global_settings->frame_width - global_settings->left_margin - global_settings->right_margin;
frame_context.orig_height = global_settings->frame_height - global_settings->top_margin - global_settings->bottom_margin;
frame_context.orig_width_nocrop = global_settings->frame_width -
FFMAX(global_settings->left_margin, 0) -
FFMAX(global_settings->right_margin, 0);
frame_context.orig_height_nocrop = global_settings->frame_height -
FFMAX(global_settings->top_margin, 0) -
FFMAX(global_settings->bottom_margin, 0);
frame_context.track = track;
frame_context.time = now;
ass_lazy_track_init();
frame_context.font_scale = global_settings->font_size_coeff *
frame_context.orig_height / frame_context.track->PlayResY;
frame_context.border_scale = ((double)frame_context.orig_height) / frame_context.track->PlayResY;
if (frame_context.orig_width * track->PlayResY == frame_context.orig_height * track->PlayResX)
frame_context.font_scale_x = 1.;
else
frame_context.font_scale_x = ((double)(frame_context.orig_width * track->PlayResY)) / (frame_context.orig_height * track->PlayResX);
priv->prev_images_root = priv->images_root;
priv->images_root = 0;
return 0;
}
static int cmp_event_layer(const void* p1, const void* p2)
{
ass_event_t* e1 = ((event_images_t*)p1)->event;
ass_event_t* e2 = ((event_images_t*)p2)->event;
if (e1->Layer < e2->Layer)
return -1;
if (e1->Layer > e2->Layer)
return 1;
if (e1->ReadOrder < e2->ReadOrder)
return -1;
if (e1->ReadOrder > e2->ReadOrder)
return 1;
return 0;
}
#define MAX_EVENTS 100
static render_priv_t* get_render_priv(ass_event_t* event)
{
if (!event->render_priv)
event->render_priv = calloc(1, sizeof(render_priv_t));
// FIXME: check render_id
if (ass_renderer->render_id != event->render_priv->render_id) {
memset(event->render_priv, 0, sizeof(render_priv_t));
event->render_priv->render_id = ass_renderer->render_id;
}
return event->render_priv;
}
typedef struct segment_s {
int a, b; // top and height
} segment_t;
static int overlap(segment_t* s1, segment_t* s2)
{
if (s1->a >= s2->b || s2->a >= s1->b)
return 0;
return 1;
}
static int cmp_segment(const void* p1, const void* p2)
{
return ((segment_t*)p1)->a - ((segment_t*)p2)->a;
}
static void shift_event(event_images_t* ei, int shift)
{
ass_image_t* cur = ei->imgs;
while (cur) {
cur->dst_y += shift;
// clip top and bottom
if (cur->dst_y < 0) {
int clip = - cur->dst_y;
cur->h -= clip;
cur->bitmap += clip * cur->stride;
cur->dst_y = 0;
}
if (cur->dst_y + cur->h >= frame_context.height) {
int clip = cur->dst_y + cur->h - frame_context.height;
cur->h -= clip;
}
if (cur->h <= 0) {
cur->h = 0;
cur->dst_y = 0;
}
cur = cur->next;
}
ei->top += shift;
}
// dir: 1 - move down
// -1 - move up
static int fit_segment(segment_t* s, segment_t* fixed, int* cnt, int dir)
{
int i;
int shift = 0;
if (dir == 1) // move down
for (i = 0; i < *cnt; ++i) {
if (s->b + shift <= fixed[i].a || s->a + shift >= fixed[i].b)
continue;
shift = fixed[i].b - s->a;
}
else // dir == -1, move up
for (i = *cnt-1; i >= 0; --i) {
if (s->b + shift <= fixed[i].a || s->a + shift >= fixed[i].b)
continue;
shift = fixed[i].a - s->b;
}
fixed[*cnt].a = s->a + shift;
fixed[*cnt].b = s->b + shift;
(*cnt)++;
qsort(fixed, *cnt, sizeof(segment_t), cmp_segment);
return shift;
}
static void fix_collisions(event_images_t* imgs, int cnt)
{
segment_t used[MAX_EVENTS];
int cnt_used = 0;
int i, j;
// fill used[] with fixed events
for (i = 0; i < cnt; ++i) {
render_priv_t* priv;
if (!imgs[i].detect_collisions) continue;
priv = get_render_priv(imgs[i].event);
if (priv->height > 0) { // it's a fixed event
segment_t s;
s.a = priv->top;
s.b = priv->top + priv->height;
if (priv->height != imgs[i].height) { // no, it's not
mp_msg(MSGT_ASS, MSGL_WARN, MSGTR_LIBASS_EventHeightHasChanged);
priv->top = 0;
priv->height = 0;
}
for (j = 0; j < cnt_used; ++j)
if (overlap(&s, used + j)) { // no, it's not
priv->top = 0;
priv->height = 0;
}
if (priv->height > 0) { // still a fixed event
used[cnt_used].a = priv->top;
used[cnt_used].b = priv->top + priv->height;
cnt_used ++;
shift_event(imgs + i, priv->top - imgs[i].top);
}
}
}
qsort(used, cnt_used, sizeof(segment_t), cmp_segment);
// try to fit other events in free spaces
for (i = 0; i < cnt; ++i) {
render_priv_t* priv;
if (!imgs[i].detect_collisions) continue;
priv = get_render_priv(imgs[i].event);
if (priv->height == 0) { // not a fixed event
int shift;
segment_t s;
s.a = imgs[i].top;
s.b = imgs[i].top + imgs[i].height;
shift = fit_segment(&s, used, &cnt_used, imgs[i].shift_direction);
if (shift) shift_event(imgs + i, shift);
// make it fixed
priv->top = imgs[i].top;
priv->height = imgs[i].height;
}
}
}
/**
* \brief compare two images
* \param i1 first image
* \param i2 second image
* \return 0 if identical, 1 if different positions, 2 if different content
*/
int ass_image_compare(ass_image_t *i1, ass_image_t *i2)
{
if (i1->w != i2->w) return 2;
if (i1->h != i2->h) return 2;
if (i1->stride != i2->stride) return 2;
if (i1->color != i2->color) return 2;
if (i1->bitmap != i2->bitmap)
return 2;
if (i1->dst_x != i2->dst_x) return 1;
if (i1->dst_y != i2->dst_y) return 1;
return 0;
}
/**
* \brief compare current and previous image list
* \param priv library handle
* \return 0 if identical, 1 if different positions, 2 if different content
*/
int ass_detect_change(ass_renderer_t *priv)
{
ass_image_t* img, *img2;
int diff;
img = priv->prev_images_root;
img2 = priv->images_root;
diff = 0;
while (img && diff < 2) {
ass_image_t* next, *next2;
next = img->next;
if (img2) {
int d = ass_image_compare(img, img2);
if (d > diff) diff = d;
next2 = img2->next;
} else {
// previous list is shorter
diff = 2;
break;
}
img = next;
img2 = next2;
}
// is the previous list longer?
if (img2)
diff = 2;
return diff;
}
/**
* \brief render a frame
* \param priv library handle
* \param track track
* \param now current video timestamp (ms)
* \param detect_change a value describing how the new images differ from the previous ones will be written here:
* 0 if identical, 1 if different positions, 2 if different content.
* Can be NULL, in that case no detection is performed.
*/
ass_image_t* ass_render_frame(ass_renderer_t *priv, ass_track_t* track, long long now, int* detect_change)
{
int i, cnt, rc;
event_images_t* last;
ass_image_t** tail;
// init frame
rc = ass_start_frame(priv, track, now);
if (rc != 0)
return 0;
// render events separately
cnt = 0;
for (i = 0; i < track->n_events; ++i) {
ass_event_t* event = track->events + i;
if ( (event->Start <= now) && (now < (event->Start + event->Duration)) ) {
if (cnt >= priv->eimg_size) {
priv->eimg_size += 100;
priv->eimg = realloc(priv->eimg, priv->eimg_size * sizeof(event_images_t));
}
rc = ass_render_event(event, priv->eimg + cnt);
if (!rc) ++cnt;
}
}
// sort by layer
qsort(priv->eimg, cnt, sizeof(event_images_t), cmp_event_layer);
// call fix_collisions for each group of events with the same layer
last = priv->eimg;
for (i = 1; i < cnt; ++i)
if (last->event->Layer != priv->eimg[i].event->Layer) {
fix_collisions(last, priv->eimg + i - last);
last = priv->eimg + i;
}
if (cnt > 0)
fix_collisions(last, priv->eimg + cnt - last);
// concat lists
tail = &ass_renderer->images_root;
for (i = 0; i < cnt; ++i) {
ass_image_t* cur = priv->eimg[i].imgs;
while (cur) {
*tail = cur;
tail = &cur->next;
cur = cur->next;
}
}
if (detect_change)
*detect_change = ass_detect_change(priv);
// free the previous image list
ass_free_images(priv->prev_images_root);
priv->prev_images_root = 0;
return ass_renderer->images_root;
}
View Git Blame Copy Permalink