1 // -*- c-basic-offset: 8; indent-tabs-mode: t -*-
2 // vim:ts=8:sw=8:noet:ai:
4 * Copyright (C) 2006 Evgeniy Stepanov <eugeni.stepanov@gmail.com>
6 * This file is part of libass.
8 * libass is free software; you can redistribute it and/or modify
9 * it under the terms of the GNU General Public License as published by
10 * the Free Software Foundation; either version 2 of the License, or
11 * (at your option) any later version.
13 * libass is distributed in the hope that it will be useful,
14 * but WITHOUT ANY WARRANTY; without even the implied warranty of
15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 * GNU General Public License for more details.
18 * You should have received a copy of the GNU General Public License along
19 * with libass; if not, write to the Free Software Foundation, Inc.,
20 * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
29 #include FT_FREETYPE_H
32 #include FT_SYNTHESIS_H
38 #include "ass_bitmap.h"
39 #include "ass_cache.h"
40 #include "ass_utils.h"
41 #include "ass_fontconfig.h"
42 #include "ass_library.h"
44 #define MAX_GLYPHS 3000
46 #define BLUR_MAX_RADIUS 50.0
47 #define ROUND(x) ((int) ((x) + .5))
48 #define SUBPIXEL_MASK 56 // d6 bitmask for subpixel accuracy adjustment
50 static int last_render_id
= 0;
52 typedef struct ass_settings_s
{
55 double font_size_coeff
; // font size multiplier
56 double line_spacing
; // additional line spacing (in frame pixels)
57 int top_margin
; // height of top margin. Everything except toptitles is shifted down by top_margin.
58 int bottom_margin
; // height of bottom margin. (frame_height - top_margin - bottom_margin) is original video height.
61 int use_margins
; // 0 - place all subtitles inside original frame
62 // 1 - use margins for placing toptitles and subtitles
63 double aspect
; // frame aspect ratio, d_width / d_height.
64 ass_hinting_t hinting
;
71 typedef struct event_images_s
{
74 int detect_collisions
;
79 struct ass_renderer_s
{
80 ass_library_t
* library
;
82 fc_instance_t
* fontconfig_priv
;
83 ass_settings_t settings
;
85 ass_synth_priv_t
* synth_priv
;
87 ass_image_t
* images_root
; // rendering result is stored here
88 ass_image_t
* prev_images_root
;
90 event_images_t
* eimg
; // temporary buffer for sorting rendered events
91 int eimg_size
; // allocated buffer size
94 typedef enum {EF_NONE
= 0, EF_KARAOKE
, EF_KARAOKE_KF
, EF_KARAOKE_KO
} effect_t
;
97 // glyph_info_t and text_info_t are used for text centering and word-wrapping operations
98 typedef struct glyph_info_s
{
101 FT_Glyph outline_glyph
;
102 bitmap_t
* bm
; // glyph bitmap
103 bitmap_t
* bm_o
; // outline bitmap
104 bitmap_t
* bm_s
; // shadow bitmap
107 char linebreak
; // the first (leading) glyph of some line ?
108 uint32_t c
[4]; // colors
109 FT_Vector advance
; // 26.6
110 effect_t effect_type
;
111 int effect_timing
; // time duration of current karaoke word
112 // after process_karaoke_effects: distance in pixels from the glyph origin.
113 // part of the glyph to the left of it is displayed in a different color.
114 int effect_skip_timing
; // delay after the end of last karaoke word
115 int asc
, desc
; // font max ascender and descender
117 int be
; // blur edges
118 double blur
; // gaussian blur
120 double frx
, fry
, frz
; // rotation
122 bitmap_hash_key_t hash_key
;
125 typedef struct line_info_s
{
129 typedef struct text_info_s
{
130 glyph_info_t
* glyphs
;
132 line_info_t lines
[MAX_LINES
];
139 // Values like current font face, color, screen position, clipping and so on are stored here.
140 typedef struct render_context_s
{
149 int alignment
; // alignment overrides go here; if zero, style value will be used
150 double frx
, fry
, frz
;
151 enum { EVENT_NORMAL
, // "normal" top-, sub- or mid- title
152 EVENT_POSITIONED
, // happens after pos(,), margins are ignored
153 EVENT_HSCROLL
, // "Banner" transition effect, text_width is unlimited
154 EVENT_VSCROLL
// "Scroll up", "Scroll down" transition effects
156 double pos_x
, pos_y
; // position
157 double org_x
, org_y
; // origin
158 char have_origin
; // origin is explicitly defined; if 0, get_base_point() is used
159 double scale_x
, scale_y
;
160 double hspacing
; // distance between letters, in pixels
161 double border
; // outline width
162 uint32_t c
[4]; // colors(Primary, Secondary, so on) in RGBA
163 int clip_x0
, clip_y0
, clip_x1
, clip_y1
;
164 char detect_collisions
;
165 uint32_t fade
; // alpha from \fad
166 char be
; // blur edges
167 double blur
; // gaussian blur
169 int drawing_mode
; // not implemented; when != 0 text is discarded, except for style override tags
171 effect_t effect_type
;
173 int effect_skip_timing
;
175 enum { SCROLL_LR
, // left-to-right
177 SCROLL_TB
, // top-to-bottom
179 } scroll_direction
; // for EVENT_HSCROLL, EVENT_VSCROLL
190 typedef struct frame_context_s
{
191 ass_renderer_t
* ass_priv
;
192 int width
, height
; // screen dimensions
193 int orig_height
; // frame height ( = screen height - margins )
194 int orig_width
; // frame width ( = screen width - margins )
195 int orig_height_nocrop
; // frame height ( = screen height - margins + cropheight)
196 int orig_width_nocrop
; // frame width ( = screen width - margins + cropwidth)
198 long long time
; // frame's timestamp, ms
200 double font_scale_x
; // x scale applied to all glyphs to preserve text aspect ratio
204 static ass_renderer_t
* ass_renderer
;
205 static ass_settings_t
* global_settings
;
206 static text_info_t text_info
;
207 static render_context_t render_context
;
208 static frame_context_t frame_context
;
210 struct render_priv_s
{
215 static void ass_lazy_track_init(void)
217 ass_track_t
* track
= frame_context
.track
;
218 if (track
->PlayResX
&& track
->PlayResY
)
220 if (!track
->PlayResX
&& !track
->PlayResY
) {
221 mp_msg(MSGT_ASS
, MSGL_WARN
, MSGTR_LIBASS_NeitherPlayResXNorPlayResYDefined
);
222 track
->PlayResX
= 384;
223 track
->PlayResY
= 288;
225 double orig_aspect
= (global_settings
->aspect
* frame_context
.height
* frame_context
.orig_width
) /
226 frame_context
.orig_height
/ frame_context
.width
;
227 if (!track
->PlayResY
&& track
->PlayResX
== 1280) {
228 track
->PlayResY
= 1024;
229 mp_msg(MSGT_ASS
, MSGL_WARN
, MSGTR_LIBASS_PlayResYUndefinedSettingY
, track
->PlayResY
);
230 } else if (!track
->PlayResY
) {
231 track
->PlayResY
= track
->PlayResX
/ orig_aspect
+ .5;
232 mp_msg(MSGT_ASS
, MSGL_WARN
, MSGTR_LIBASS_PlayResYUndefinedSettingY
, track
->PlayResY
);
233 } else if (!track
->PlayResX
&& track
->PlayResY
== 1024) {
234 track
->PlayResX
= 1280;
235 mp_msg(MSGT_ASS
, MSGL_WARN
, MSGTR_LIBASS_PlayResXUndefinedSettingX
, track
->PlayResX
);
236 } else if (!track
->PlayResX
) {
237 track
->PlayResX
= track
->PlayResY
* orig_aspect
+ .5;
238 mp_msg(MSGT_ASS
, MSGL_WARN
, MSGTR_LIBASS_PlayResXUndefinedSettingX
, track
->PlayResX
);
243 ass_renderer_t
* ass_renderer_init(ass_library_t
* library
)
247 ass_renderer_t
* priv
= 0;
248 int vmajor
, vminor
, vpatch
;
250 memset(&render_context
, 0, sizeof(render_context
));
251 memset(&frame_context
, 0, sizeof(frame_context
));
252 memset(&text_info
, 0, sizeof(text_info
));
254 error
= FT_Init_FreeType( &ft
);
256 mp_msg(MSGT_ASS
, MSGL_FATAL
, MSGTR_LIBASS_FT_Init_FreeTypeFailed
);
260 FT_Library_Version(ft
, &vmajor
, &vminor
, &vpatch
);
261 mp_msg(MSGT_ASS
, MSGL_V
, "FreeType library version: %d.%d.%d\n",
262 vmajor
, vminor
, vpatch
);
263 mp_msg(MSGT_ASS
, MSGL_V
, "FreeType headers version: %d.%d.%d\n",
264 FREETYPE_MAJOR
, FREETYPE_MINOR
, FREETYPE_PATCH
);
266 priv
= calloc(1, sizeof(ass_renderer_t
));
268 FT_Done_FreeType(ft
);
272 priv
->synth_priv
= ass_synth_init(BLUR_MAX_RADIUS
);
274 priv
->library
= library
;
275 priv
->ftlibrary
= ft
;
276 // images_root and related stuff is zero-filled in calloc
278 ass_font_cache_init();
279 ass_bitmap_cache_init();
280 ass_composite_cache_init();
281 ass_glyph_cache_init();
283 text_info
.glyphs
= calloc(MAX_GLYPHS
, sizeof(glyph_info_t
));
286 if (priv
) mp_msg(MSGT_ASS
, MSGL_INFO
, MSGTR_LIBASS_Init
);
287 else mp_msg(MSGT_ASS
, MSGL_ERR
, MSGTR_LIBASS_InitFailed
);
292 void ass_renderer_done(ass_renderer_t
* priv
)
294 ass_font_cache_done();
295 ass_bitmap_cache_done();
296 ass_composite_cache_done();
297 ass_glyph_cache_done();
298 if (render_context
.stroker
) {
299 FT_Stroker_Done(render_context
.stroker
);
300 render_context
.stroker
= 0;
302 if (priv
&& priv
->ftlibrary
) FT_Done_FreeType(priv
->ftlibrary
);
303 if (priv
&& priv
->fontconfig_priv
) fontconfig_done(priv
->fontconfig_priv
);
304 if (priv
&& priv
->synth_priv
) ass_synth_done(priv
->synth_priv
);
305 if (priv
&& priv
->eimg
) free(priv
->eimg
);
306 if (priv
) free(priv
);
307 if (text_info
.glyphs
) free(text_info
.glyphs
);
311 * \brief Create a new ass_image_t
312 * Parameters are the same as ass_image_t fields.
314 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
)
316 ass_image_t
* img
= calloc(1, sizeof(ass_image_t
));
320 img
->stride
= stride
;
321 img
->bitmap
= bitmap
;
330 * \brief convert bitmap glyph into ass_image_t struct(s)
331 * \param bit freetype bitmap glyph, FT_PIXEL_MODE_GRAY
332 * \param dst_x bitmap x coordinate in video frame
333 * \param dst_y bitmap y coordinate in video frame
334 * \param color first color, RGBA
335 * \param color2 second color, RGBA
336 * \param brk x coordinate relative to glyph origin, color is used to the left of brk, color2 - to the right
337 * \param tail pointer to the last image's next field, head of the generated list should be stored here
338 * \return pointer to the new list tail
339 * Performs clipping. Uses my_draw_bitmap for actual bitmap convertion.
341 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
)
343 // brk is relative to dst_x
344 // color = color left of brk
345 // color2 = color right of brk
346 int b_x0
, b_y0
, b_x1
, b_y1
; // visible part of the bitmap
347 int clip_x0
, clip_y0
, clip_x1
, clip_y1
;
356 clip_x0
= render_context
.clip_x0
;
357 clip_y0
= render_context
.clip_y0
;
358 clip_x1
= render_context
.clip_x1
;
359 clip_y1
= render_context
.clip_y1
;
365 tmp
= dst_x
- clip_x0
;
367 mp_msg(MSGT_ASS
, MSGL_DBG2
, "clip left\n");
370 tmp
= dst_y
- clip_y0
;
372 mp_msg(MSGT_ASS
, MSGL_DBG2
, "clip top\n");
375 tmp
= clip_x1
- dst_x
- bm
->w
;
377 mp_msg(MSGT_ASS
, MSGL_DBG2
, "clip right\n");
380 tmp
= clip_y1
- dst_y
- bm
->h
;
382 mp_msg(MSGT_ASS
, MSGL_DBG2
, "clip bottom\n");
386 if ((b_y0
>= b_y1
) || (b_x0
>= b_x1
))
389 if (brk
> b_x0
) { // draw left part
390 if (brk
> b_x1
) brk
= b_x1
;
391 img
= my_draw_bitmap(bm
->buffer
+ bm
->w
* b_y0
+ b_x0
,
392 brk
- b_x0
, b_y1
- b_y0
, bm
->w
,
393 dst_x
+ b_x0
, dst_y
+ b_y0
, color
);
397 if (brk
< b_x1
) { // draw right part
398 if (brk
< b_x0
) brk
= b_x0
;
399 img
= my_draw_bitmap(bm
->buffer
+ bm
->w
* b_y0
+ brk
,
400 b_x1
- brk
, b_y1
- b_y0
, bm
->w
,
401 dst_x
+ brk
, dst_y
+ b_y0
, color2
);
409 * \brief Calculate overlapping area of two consecutive bitmaps and in case they
410 * overlap, composite them together
411 * Mainly useful for translucent glyphs and especially borders, to avoid the
412 * luminance adding up where they overlap (which looks ugly)
414 static void render_overlap(ass_image_t
** last_tail
, ass_image_t
** tail
, bitmap_hash_key_t
*last_hash
, bitmap_hash_key_t
* hash
) {
415 int left
, top
, bottom
, right
;
416 int old_left
, old_top
, w
, h
, cur_left
, cur_top
;
417 int x
, y
, opos
, cpos
;
419 composite_hash_key_t hk
;
420 composite_hash_val_t
*hv
;
421 composite_hash_key_t
*nhk
;
422 int ax
= (*last_tail
)->dst_x
;
423 int ay
= (*last_tail
)->dst_y
;
424 int aw
= (*last_tail
)->w
;
425 int ah
= (*last_tail
)->h
;
426 int bx
= (*tail
)->dst_x
;
427 int by
= (*tail
)->dst_y
;
433 if ((*last_tail
)->bitmap
== (*tail
)->bitmap
)
436 // Calculate overlap coordinates
437 left
= (ax
> bx
) ? ax
: bx
;
438 top
= (ay
> by
) ? ay
: by
;
439 right
= ((ax
+aw
) < (bx
+bw
)) ? (ax
+aw
) : (bx
+bw
);
440 bottom
= ((ay
+ah
) < (by
+bh
)) ? (ay
+ah
) : (by
+bh
);
441 if ((right
<= left
) || (bottom
<= top
))
443 old_left
= left
-(ax
);
447 cur_left
= left
-(bx
);
451 memcpy(&hk
.a
, last_hash
, sizeof(*last_hash
));
452 memcpy(&hk
.b
, hash
, sizeof(*hash
));
461 hv
= cache_find_composite(&hk
);
463 (*last_tail
)->bitmap
= hv
->a
;
464 (*tail
)->bitmap
= hv
->b
;
468 // Allocate new bitmaps and copy over data
469 a
= (*last_tail
)->bitmap
;
471 (*last_tail
)->bitmap
= malloc(aw
*ah
);
472 (*tail
)->bitmap
= malloc(bw
*bh
);
473 memcpy((*last_tail
)->bitmap
, a
, aw
*ah
);
474 memcpy((*tail
)->bitmap
, b
, bw
*bh
);
476 // Composite overlapping area
478 for (x
=0; x
<w
; x
++) {
479 opos
= (old_top
+y
)*(aw
) + (old_left
+x
);
480 cpos
= (cur_top
+y
)*(bw
) + (cur_left
+x
);
481 m
= (a
[opos
] > b
[cpos
]) ? a
[opos
] : b
[cpos
];
482 (*last_tail
)->bitmap
[opos
] = 0;
483 (*tail
)->bitmap
[cpos
] = m
;
486 // Insert bitmaps into the cache
487 nhk
= calloc(1, sizeof(*nhk
));
488 memcpy(nhk
, &hk
, sizeof(*nhk
));
489 hv
= calloc(1, sizeof(*hv
));
490 hv
->a
= (*last_tail
)->bitmap
;
491 hv
->b
= (*tail
)->bitmap
;
492 cache_add_composite(nhk
, hv
);
496 * \brief Convert text_info_t struct to ass_image_t list
497 * Splits glyphs in halves when needed (for \kf karaoke).
499 static ass_image_t
* render_text(text_info_t
* text_info
, int dst_x
, int dst_y
)
505 ass_image_t
** tail
= &head
;
506 ass_image_t
** last_tail
= 0;
507 ass_image_t
** here_tail
= 0;
508 bitmap_hash_key_t
* last_hash
= 0;
510 for (i
= 0; i
< text_info
->length
; ++i
) {
511 glyph_info_t
* info
= text_info
->glyphs
+ i
;
512 if ((info
->symbol
== 0) || (info
->symbol
== '\n') || !info
->bm_s
|| (info
->shadow
== 0))
515 pen_x
= dst_x
+ info
->pos
.x
+ ROUND(info
->shadow
* frame_context
.border_scale
);
516 pen_y
= dst_y
+ info
->pos
.y
+ ROUND(info
->shadow
* frame_context
.border_scale
);
520 tail
= render_glyph(bm
, pen_x
, pen_y
, info
->c
[3], 0, 1000000, tail
);
521 if (last_tail
&& tail
!= here_tail
&& ((info
->c
[3] & 0xff) > 0))
522 render_overlap(last_tail
, here_tail
, last_hash
, &info
->hash_key
);
523 last_tail
= here_tail
;
524 last_hash
= &info
->hash_key
;
528 for (i
= 0; i
< text_info
->length
; ++i
) {
529 glyph_info_t
* info
= text_info
->glyphs
+ i
;
530 if ((info
->symbol
== 0) || (info
->symbol
== '\n') || !info
->bm_o
)
533 pen_x
= dst_x
+ info
->pos
.x
;
534 pen_y
= dst_y
+ info
->pos
.y
;
537 if ((info
->effect_type
== EF_KARAOKE_KO
) && (info
->effect_timing
<= info
->bbox
.xMax
)) {
541 tail
= render_glyph(bm
, pen_x
, pen_y
, info
->c
[2], 0, 1000000, tail
);
542 if (last_tail
&& tail
!= here_tail
&& ((info
->c
[2] & 0xff) > 0))
543 render_overlap(last_tail
, here_tail
, last_hash
, &info
->hash_key
);
544 last_tail
= here_tail
;
545 last_hash
= &info
->hash_key
;
548 for (i
= 0; i
< text_info
->length
; ++i
) {
549 glyph_info_t
* info
= text_info
->glyphs
+ i
;
550 if ((info
->symbol
== 0) || (info
->symbol
== '\n') || !info
->bm
)
553 pen_x
= dst_x
+ info
->pos
.x
;
554 pen_y
= dst_y
+ info
->pos
.y
;
557 if ((info
->effect_type
== EF_KARAOKE
) || (info
->effect_type
== EF_KARAOKE_KO
)) {
558 if (info
->effect_timing
> info
->bbox
.xMax
)
559 tail
= render_glyph(bm
, pen_x
, pen_y
, info
->c
[0], 0, 1000000, tail
);
561 tail
= render_glyph(bm
, pen_x
, pen_y
, info
->c
[1], 0, 1000000, tail
);
562 } else if (info
->effect_type
== EF_KARAOKE_KF
) {
563 tail
= render_glyph(bm
, pen_x
, pen_y
, info
->c
[0], info
->c
[1], info
->effect_timing
, tail
);
565 tail
= render_glyph(bm
, pen_x
, pen_y
, info
->c
[0], 0, 1000000, tail
);
573 * \brief Mapping between script and screen coordinates
575 static int x2scr(double x
) {
576 return x
*frame_context
.orig_width_nocrop
/ frame_context
.track
->PlayResX
+
577 FFMAX(global_settings
->left_margin
, 0);
579 static double x2scr_pos(double x
) {
580 return x
*frame_context
.orig_width
/ frame_context
.track
->PlayResX
+
581 global_settings
->left_margin
;
584 * \brief Mapping between script and screen coordinates
586 static double y2scr(double y
) {
587 return y
* frame_context
.orig_height_nocrop
/ frame_context
.track
->PlayResY
+
588 FFMAX(global_settings
->top_margin
, 0);
590 static double y2scr_pos(double y
) {
591 return y
* frame_context
.orig_height
/ frame_context
.track
->PlayResY
+
592 global_settings
->top_margin
;
595 // the same for toptitles
596 static int y2scr_top(double y
) {
597 if (global_settings
->use_margins
)
598 return y
* frame_context
.orig_height_nocrop
/ frame_context
.track
->PlayResY
;
600 return y
* frame_context
.orig_height_nocrop
/ frame_context
.track
->PlayResY
+
601 FFMAX(global_settings
->top_margin
, 0);
603 // the same for subtitles
604 static int y2scr_sub(double y
) {
605 if (global_settings
->use_margins
)
606 return y
* frame_context
.orig_height_nocrop
/ frame_context
.track
->PlayResY
+
607 FFMAX(global_settings
->top_margin
, 0) +
608 FFMAX(global_settings
->bottom_margin
, 0);
610 return y
* frame_context
.orig_height_nocrop
/ frame_context
.track
->PlayResY
+
611 FFMAX(global_settings
->top_margin
, 0);
614 static void compute_string_bbox( text_info_t
* info
, FT_BBox
*abbox
) {
618 if (text_info
.length
> 0) {
621 bbox
.yMin
= - d6_to_int(text_info
.lines
[0].asc
) + text_info
.glyphs
[0].pos
.y
;
622 bbox
.yMax
= d6_to_int(text_info
.height
- text_info
.lines
[0].asc
) + text_info
.glyphs
[0].pos
.y
;
624 for (i
= 0; i
< text_info
.length
; ++i
) {
625 int s
= text_info
.glyphs
[i
].pos
.x
;
626 int e
= s
+ d6_to_int(text_info
.glyphs
[i
].advance
.x
);
627 bbox
.xMin
= FFMIN(bbox
.xMin
, s
);
628 bbox
.xMax
= FFMAX(bbox
.xMax
, e
);
631 bbox
.xMin
= bbox
.xMax
= bbox
.yMin
= bbox
.yMax
= 0;
633 /* return string bbox */
639 * \brief Check if starting part of (*p) matches sample. If true, shift p to the first symbol after the matching part.
641 static inline int mystrcmp(char** p
, const char* sample
) {
642 int len
= strlen(sample
);
643 if (strncmp(*p
, sample
, len
) == 0) {
650 static void change_font_size(double sz
)
652 double size
= sz
* frame_context
.font_scale
;
656 else if (size
> frame_context
.height
* 2)
657 size
= frame_context
.height
* 2;
659 ass_font_set_size(render_context
.font
, size
);
661 render_context
.font_size
= sz
;
665 * \brief Change current font, using setting from render_context.
667 static void update_font(void)
670 ass_renderer_t
* priv
= frame_context
.ass_priv
;
671 ass_font_desc_t desc
;
672 desc
.family
= strdup(render_context
.family
);
674 val
= render_context
.bold
;
675 // 0 = normal, 1 = bold, >1 = exact weight
676 if (val
== 0) val
= 80; // normal
677 else if (val
== 1) val
= 200; // bold
680 val
= render_context
.italic
;
681 if (val
== 0) val
= 0; // normal
682 else if (val
== 1) val
= 110; //italic
685 render_context
.font
= ass_font_new(priv
->library
, priv
->ftlibrary
, priv
->fontconfig_priv
, &desc
);
688 if (render_context
.font
)
689 change_font_size(render_context
.font_size
);
693 * \brief Change border width
694 * negative value resets border to style value
696 static void change_border(double border
)
699 if (!render_context
.font
) return;
702 if (render_context
.style
->BorderStyle
== 1)
703 border
= render_context
.style
->Outline
;
707 render_context
.border
= border
;
709 b
= 64 * border
* frame_context
.border_scale
;
711 if (!render_context
.stroker
) {
713 #if (FREETYPE_MAJOR > 2) || ((FREETYPE_MAJOR == 2) && (FREETYPE_MINOR > 1))
714 error
= FT_Stroker_New( ass_renderer
->ftlibrary
, &render_context
.stroker
);
716 error
= FT_Stroker_New( render_context
.font
->faces
[0]->memory
, &render_context
.stroker
);
719 mp_msg(MSGT_ASS
, MSGL_V
, "failed to get stroker\n");
720 render_context
.stroker
= 0;
723 if (render_context
.stroker
)
724 FT_Stroker_Set( render_context
.stroker
, b
,
725 FT_STROKER_LINECAP_ROUND
,
726 FT_STROKER_LINEJOIN_ROUND
,
729 FT_Stroker_Done(render_context
.stroker
);
730 render_context
.stroker
= 0;
734 #define _r(c) ((c)>>24)
735 #define _g(c) (((c)>>16)&0xFF)
736 #define _b(c) (((c)>>8)&0xFF)
737 #define _a(c) ((c)&0xFF)
740 * \brief Calculate a weighted average of two colors
741 * calculates c1*(1-a) + c2*a, but separately for each component except alpha
743 static void change_color(uint32_t* var
, uint32_t new, double pwr
)
745 (*var
)= ((uint32_t)(_r(*var
) * (1 - pwr
) + _r(new) * pwr
) << 24) +
746 ((uint32_t)(_g(*var
) * (1 - pwr
) + _g(new) * pwr
) << 16) +
747 ((uint32_t)(_b(*var
) * (1 - pwr
) + _b(new) * pwr
) << 8) +
751 // like change_color, but for alpha component only
752 static void change_alpha(uint32_t* var
, uint32_t new, double pwr
)
754 *var
= (_r(*var
) << 24) + (_g(*var
) << 16) + (_b(*var
) << 8) + (_a(*var
) * (1 - pwr
) + _a(new) * pwr
);
758 * \brief Multiply two alpha values
759 * \param a first value
760 * \param b second value
761 * \return result of multiplication
762 * Parameters and result are limited by 0xFF.
764 static uint32_t mult_alpha(uint32_t a
, uint32_t b
)
766 return 0xFF - (0xFF - a
) * (0xFF - b
) / 0xFF;
770 * \brief Calculate alpha value by piecewise linear function
771 * Used for \fad, \fade implementation.
773 static unsigned interpolate_alpha(long long now
,
774 long long t1
, long long t2
, long long t3
, long long t4
,
775 unsigned a1
, unsigned a2
, unsigned a3
)
781 } else if (now
>= t4
) {
783 } else if (now
< t2
) { // and > t1
784 cf
= ((double)(now
- t1
)) / (t2
- t1
);
785 a
= a1
* (1 - cf
) + a2
* cf
;
786 } else if (now
> t3
) {
787 cf
= ((double)(now
- t3
)) / (t4
- t3
);
788 a
= a2
* (1 - cf
) + a3
* cf
;
789 } else { // t2 <= now <= t3
796 static void reset_render_context(void);
799 * \brief Parse style override tag.
800 * \param p string to parse
801 * \param pwr multiplier for some tag effects (comes from \t tags)
803 static char* parse_tag(char* p
, double pwr
) {
804 #define skip_to(x) while ((*p != (x)) && (*p != '}') && (*p != 0)) { ++p;}
805 #define skip(x) if (*p == (x)) ++p; else { return p; }
809 if ((*p
== '}') || (*p
== 0))
812 // New tags introduced in vsfilter 2.39
813 if (mystrcmp(&p
, "xbord")) {
815 if (mystrtod(&p
, &val
))
816 mp_msg(MSGT_ASS
, MSGL_V
, "stub: \\xbord%.2f\n", val
);
817 } else if (mystrcmp(&p
, "ybord")) {
819 if (mystrtod(&p
, &val
))
820 mp_msg(MSGT_ASS
, MSGL_V
, "stub: \\ybord%.2f\n", val
);
821 } else if (mystrcmp(&p
, "xshad")) {
823 if (mystrtoi(&p
, &val
))
824 mp_msg(MSGT_ASS
, MSGL_V
, "stub: \\xshad%d\n", val
);
825 } else if (mystrcmp(&p
, "yshad")) {
827 if (mystrtoi(&p
, &val
))
828 mp_msg(MSGT_ASS
, MSGL_V
, "stub: \\yshad%d\n", val
);
829 } else if (mystrcmp(&p
, "fax")) {
831 if (mystrtoi(&p
, &val
))
832 mp_msg(MSGT_ASS
, MSGL_V
, "stub: \\fax%d\n", val
);
833 } else if (mystrcmp(&p
, "fay")) {
835 if (mystrtoi(&p
, &val
))
836 mp_msg(MSGT_ASS
, MSGL_V
, "stub: \\fay%d\n", val
);
837 } else if (mystrcmp(&p
, "iclip")) {
841 res
&= mystrtoi(&p
, &x0
);
843 res
&= mystrtoi(&p
, &y0
);
845 res
&= mystrtoi(&p
, &x1
);
847 res
&= mystrtoi(&p
, &y1
);
849 mp_msg(MSGT_ASS
, MSGL_V
, "stub: \\iclip(%d,%d,%d,%d)\n", x0
, y0
, x1
, y1
);
850 } else if (mystrcmp(&p
, "blur")) {
852 if (mystrtod(&p
, &val
)) {
853 val
= (val
< 0) ? 0 : val
;
854 val
= (val
> BLUR_MAX_RADIUS
) ? BLUR_MAX_RADIUS
: val
;
855 render_context
.blur
= val
;
857 render_context
.blur
= 0.0;
859 } else if (mystrcmp(&p
, "fsc")) {
863 if (mystrtod(&p
, &val
)) {
865 render_context
.scale_x
= render_context
.scale_x
* ( 1 - pwr
) + val
* pwr
;
867 render_context
.scale_x
= render_context
.style
->ScaleX
;
868 } else if (tp
== 'y') {
869 if (mystrtod(&p
, &val
)) {
871 render_context
.scale_y
= render_context
.scale_y
* ( 1 - pwr
) + val
* pwr
;
873 render_context
.scale_y
= render_context
.style
->ScaleY
;
875 } else if (mystrcmp(&p
, "fsp")) {
877 if (mystrtod(&p
, &val
))
878 render_context
.hspacing
= render_context
.hspacing
* ( 1 - pwr
) + val
* pwr
;
880 render_context
.hspacing
= render_context
.style
->Spacing
;
881 } else if (mystrcmp(&p
, "fs")) {
883 if (mystrtod(&p
, &val
))
884 val
= render_context
.font_size
* ( 1 - pwr
) + val
* pwr
;
886 val
= render_context
.style
->FontSize
;
887 if (render_context
.font
)
888 change_font_size(val
);
889 } else if (mystrcmp(&p
, "bord")) {
891 if (mystrtod(&p
, &val
))
892 val
= render_context
.border
* ( 1 - pwr
) + val
* pwr
;
894 val
= -1.; // reset to default
896 } else if (mystrcmp(&p
, "move")) {
897 double x1
, x2
, y1
, y2
;
898 long long t1
, t2
, delta_t
, t
;
914 mp_msg(MSGT_ASS
, MSGL_DBG2
, "movement6: (%f, %f) -> (%f, %f), (%" PRId64
" .. %" PRId64
")\n",
915 x1
, y1
, x2
, y2
, (int64_t)t1
, (int64_t)t2
);
918 t2
= render_context
.event
->Duration
;
919 mp_msg(MSGT_ASS
, MSGL_DBG2
, "movement: (%f, %f) -> (%f, %f)\n", x1
, y1
, x2
, y2
);
923 t
= frame_context
.time
- render_context
.event
->Start
;
928 else k
= ((double)(t
- t1
)) / delta_t
;
929 x
= k
* (x2
- x1
) + x1
;
930 y
= k
* (y2
- y1
) + y1
;
931 if (render_context
.evt_type
!= EVENT_POSITIONED
) {
932 render_context
.pos_x
= x
;
933 render_context
.pos_y
= y
;
934 render_context
.detect_collisions
= 0;
935 render_context
.evt_type
= EVENT_POSITIONED
;
937 } else if (mystrcmp(&p
, "frx")) {
939 if (mystrtod(&p
, &val
)) {
941 render_context
.frx
= val
* pwr
+ render_context
.frx
* (1-pwr
);
943 render_context
.frx
= 0.;
944 } else if (mystrcmp(&p
, "fry")) {
946 if (mystrtod(&p
, &val
)) {
948 render_context
.fry
= val
* pwr
+ render_context
.fry
* (1-pwr
);
950 render_context
.fry
= 0.;
951 } else if (mystrcmp(&p
, "frz") || mystrcmp(&p
, "fr")) {
953 if (mystrtod(&p
, &val
)) {
955 render_context
.frz
= val
* pwr
+ render_context
.frz
* (1-pwr
);
957 render_context
.frz
= M_PI
* render_context
.style
->Angle
/ 180.;
958 } else if (mystrcmp(&p
, "fn")) {
963 family
= malloc(p
- start
+ 1);
964 strncpy(family
, start
, p
- start
);
965 family
[p
- start
] = '\0';
967 family
= strdup(render_context
.style
->FontName
);
968 if (render_context
.family
)
969 free(render_context
.family
);
970 render_context
.family
= family
;
972 } else if (mystrcmp(&p
, "alpha")) {
975 if (strtocolor(&p
, &val
)) {
976 unsigned char a
= val
>> 24;
977 for (i
= 0; i
< 4; ++i
)
978 change_alpha(&render_context
.c
[i
], a
, pwr
);
980 change_alpha(&render_context
.c
[0], render_context
.style
->PrimaryColour
, pwr
);
981 change_alpha(&render_context
.c
[1], render_context
.style
->SecondaryColour
, pwr
);
982 change_alpha(&render_context
.c
[2], render_context
.style
->OutlineColour
, pwr
);
983 change_alpha(&render_context
.c
[3], render_context
.style
->BackColour
, pwr
);
986 } else if (mystrcmp(&p
, "an")) {
988 if (mystrtoi(&p
, &val
) && val
) {
989 int v
= (val
- 1) / 3; // 0, 1 or 2 for vertical alignment
990 mp_msg(MSGT_ASS
, MSGL_DBG2
, "an %d\n", val
);
991 if (v
!= 0) v
= 3 - v
;
992 val
= ((val
- 1) % 3) + 1; // horizontal alignment
994 mp_msg(MSGT_ASS
, MSGL_DBG2
, "align %d\n", val
);
995 render_context
.alignment
= val
;
997 render_context
.alignment
= render_context
.style
->Alignment
;
998 } else if (mystrcmp(&p
, "a")) {
1000 if (mystrtoi(&p
, &val
) && val
)
1001 render_context
.alignment
= val
;
1003 render_context
.alignment
= render_context
.style
->Alignment
;
1004 } else if (mystrcmp(&p
, "pos")) {
1011 mp_msg(MSGT_ASS
, MSGL_DBG2
, "pos(%f, %f)\n", v1
, v2
);
1012 if (render_context
.evt_type
!= EVENT_POSITIONED
) {
1013 render_context
.evt_type
= EVENT_POSITIONED
;
1014 render_context
.detect_collisions
= 0;
1015 render_context
.pos_x
= v1
;
1016 render_context
.pos_y
= v2
;
1018 } else if (mystrcmp(&p
, "fad")) {
1020 long long t1
, t2
, t3
, t4
;
1021 if (*p
== 'e') ++p
; // either \fad or \fade
1027 // 2-argument version (\fad, according to specs)
1028 // a1 and a2 are fade-in and fade-out durations
1030 t4
= render_context
.event
->Duration
;
1037 // 6-argument version (\fade)
1038 // a1 and a2 (and a3) are opacity values
1051 render_context
.fade
= interpolate_alpha(frame_context
.time
- render_context
.event
->Start
, t1
, t2
, t3
, t4
, a1
, a2
, a3
);
1052 } else if (mystrcmp(&p
, "org")) {
1059 mp_msg(MSGT_ASS
, MSGL_DBG2
, "org(%d, %d)\n", v1
, v2
);
1060 // render_context.evt_type = EVENT_POSITIONED;
1061 render_context
.org_x
= v1
;
1062 render_context
.org_y
= v2
;
1063 render_context
.have_origin
= 1;
1064 render_context
.detect_collisions
= 0;
1065 } else if (mystrcmp(&p
, "t")) {
1070 long long t1
, t2
, t
, delta_t
;
1073 for (cnt
= 0; cnt
< 3; ++cnt
) {
1076 v
[cnt
] = strtod(p
, &p
);
1080 v1
= v
[0]; v2
= v
[1]; v3
= v
[2];
1081 } else if (cnt
== 2) {
1082 v1
= v
[0]; v2
= v
[1]; v3
= 1.;
1083 } else if (cnt
== 1) {
1084 v1
= 0; v2
= render_context
.event
->Duration
; v3
= v
[0];
1085 } else { // cnt == 0
1086 v1
= 0; v2
= render_context
.event
->Duration
; v3
= 1.;
1088 render_context
.detect_collisions
= 0;
1094 t
= frame_context
.time
- render_context
.event
->Start
; // FIXME: move to render_context
1100 assert(delta_t
!= 0.);
1101 k
= pow(((double)(t
- t1
)) / delta_t
, v3
);
1104 p
= parse_tag(p
, k
); // maybe k*pwr ? no, specs forbid nested \t's
1105 skip_to(')'); // in case there is some unknown tag or a comment
1107 } else if (mystrcmp(&p
, "clip")) {
1111 res
&= mystrtoi(&p
, &x0
);
1113 res
&= mystrtoi(&p
, &y0
);
1115 res
&= mystrtoi(&p
, &x1
);
1117 res
&= mystrtoi(&p
, &y1
);
1120 render_context
.clip_x0
= render_context
.clip_x0
* (1-pwr
) + x0
* pwr
;
1121 render_context
.clip_x1
= render_context
.clip_x1
* (1-pwr
) + x1
* pwr
;
1122 render_context
.clip_y0
= render_context
.clip_y0
* (1-pwr
) + y0
* pwr
;
1123 render_context
.clip_y1
= render_context
.clip_y1
* (1-pwr
) + y1
* pwr
;
1125 render_context
.clip_x0
= 0;
1126 render_context
.clip_y0
= 0;
1127 render_context
.clip_x1
= frame_context
.track
->PlayResX
;
1128 render_context
.clip_y1
= frame_context
.track
->PlayResY
;
1130 } else if (mystrcmp(&p
, "c")) {
1132 if (!strtocolor(&p
, &val
))
1133 val
= render_context
.style
->PrimaryColour
;
1134 mp_msg(MSGT_ASS
, MSGL_DBG2
, "color: %X\n", val
);
1135 change_color(&render_context
.c
[0], val
, pwr
);
1136 } else if ((*p
>= '1') && (*p
<= '4') && (++p
) && (mystrcmp(&p
, "c") || mystrcmp(&p
, "a"))) {
1141 assert((n
>= '1') && (n
<= '4'));
1142 if (!strtocolor(&p
, &val
))
1144 case '1': val
= render_context
.style
->PrimaryColour
; break;
1145 case '2': val
= render_context
.style
->SecondaryColour
; break;
1146 case '3': val
= render_context
.style
->OutlineColour
; break;
1147 case '4': val
= render_context
.style
->BackColour
; break;
1148 default : val
= 0; break; // impossible due to assert; avoid compilation warning
1151 case 'c': change_color(render_context
.c
+ cidx
, val
, pwr
); break;
1152 case 'a': change_alpha(render_context
.c
+ cidx
, val
>> 24, pwr
); break;
1153 default: mp_msg(MSGT_ASS
, MSGL_WARN
, MSGTR_LIBASS_BadCommand
, n
, cmd
); break;
1155 mp_msg(MSGT_ASS
, MSGL_DBG2
, "single c/a at %f: %c%c = %X \n", pwr
, n
, cmd
, render_context
.c
[cidx
]);
1156 } else if (mystrcmp(&p
, "r")) {
1157 reset_render_context();
1158 } else if (mystrcmp(&p
, "be")) {
1160 if (mystrtoi(&p
, &val
)) {
1161 // Clamp to 10, since high values need excessive CPU
1162 val
= (val
< 0) ? 0 : val
;
1163 val
= (val
> 10) ? 10 : val
;
1164 render_context
.be
= val
;
1166 render_context
.be
= 0;
1167 } else if (mystrcmp(&p
, "b")) {
1169 if (mystrtoi(&p
, &b
)) {
1171 render_context
.bold
= b
;
1173 render_context
.bold
= render_context
.style
->Bold
;
1175 } else if (mystrcmp(&p
, "i")) {
1177 if (mystrtoi(&p
, &i
)) {
1179 render_context
.italic
= i
;
1181 render_context
.italic
= render_context
.style
->Italic
;
1183 } else if (mystrcmp(&p
, "kf") || mystrcmp(&p
, "K")) {
1186 render_context
.effect_type
= EF_KARAOKE_KF
;
1187 if (render_context
.effect_timing
)
1188 render_context
.effect_skip_timing
+= render_context
.effect_timing
;
1189 render_context
.effect_timing
= val
* 10;
1190 } else if (mystrcmp(&p
, "ko")) {
1193 render_context
.effect_type
= EF_KARAOKE_KO
;
1194 if (render_context
.effect_timing
)
1195 render_context
.effect_skip_timing
+= render_context
.effect_timing
;
1196 render_context
.effect_timing
= val
* 10;
1197 } else if (mystrcmp(&p
, "k")) {
1200 render_context
.effect_type
= EF_KARAOKE
;
1201 if (render_context
.effect_timing
)
1202 render_context
.effect_skip_timing
+= render_context
.effect_timing
;
1203 render_context
.effect_timing
= val
* 10;
1204 } else if (mystrcmp(&p
, "shad")) {
1206 if (mystrtoi(&p
, &val
))
1207 render_context
.shadow
= val
;
1209 render_context
.shadow
= render_context
.style
->Shadow
;
1210 } else if (mystrcmp(&p
, "pbo")) {
1212 mystrtoi(&p
, &val
); // ignored
1213 } else if (mystrcmp(&p
, "p")) {
1215 if (!mystrtoi(&p
, &val
))
1217 render_context
.drawing_mode
= !!val
;
1227 * \brief Get next ucs4 char from string, parsing and executing style overrides
1228 * \param str string pointer
1229 * \return ucs4 code of the next char
1230 * On return str points to the unparsed part of the string
1232 static unsigned get_next_char(char** str
)
1236 if (*p
== '{') { // '\0' goes here
1239 p
= parse_tag(p
, 1.);
1240 if (*p
== '}') { // end of tag
1247 } else if (*p
!= '\\')
1248 mp_msg(MSGT_ASS
, MSGL_V
, "Unable to parse: \"%s\" \n", p
);
1259 if ((*(p
+1) == 'N') || ((*(p
+1) == 'n') && (frame_context
.track
->WrapStyle
== 2))) {
1263 } else if ((*(p
+1) == 'n') || (*(p
+1) == 'h')) {
1269 chr
= utf8_get_char((const char **)&p
);
1274 static void apply_transition_effects(ass_event_t
* event
)
1278 char* p
= event
->Effect
;
1280 if (!p
|| !*p
) return;
1283 while (cnt
< 4 && (p
= strchr(p
, ';'))) {
1284 v
[cnt
++] = atoi(++p
);
1287 if (strncmp(event
->Effect
, "Banner;", 7) == 0) {
1290 mp_msg(MSGT_ASS
, MSGL_V
, "Error parsing effect: %s \n", event
->Effect
);
1293 if (cnt
>= 2 && v
[1] == 0) // right-to-left
1294 render_context
.scroll_direction
= SCROLL_RL
;
1295 else // left-to-right
1296 render_context
.scroll_direction
= SCROLL_LR
;
1299 if (delay
== 0) delay
= 1; // ?
1300 render_context
.scroll_shift
= (frame_context
.time
- render_context
.event
->Start
) / delay
;
1301 render_context
.evt_type
= EVENT_HSCROLL
;
1305 if (strncmp(event
->Effect
, "Scroll up;", 10) == 0) {
1306 render_context
.scroll_direction
= SCROLL_BT
;
1307 } else if (strncmp(event
->Effect
, "Scroll down;", 12) == 0) {
1308 render_context
.scroll_direction
= SCROLL_TB
;
1310 mp_msg(MSGT_ASS
, MSGL_V
, "Unknown transition effect: %s \n", event
->Effect
);
1313 // parse scroll up/down parameters
1318 mp_msg(MSGT_ASS
, MSGL_V
, "Error parsing effect: %s \n", event
->Effect
);
1322 if (delay
== 0) delay
= 1; // ?
1323 render_context
.scroll_shift
= (frame_context
.time
- render_context
.event
->Start
) / delay
;
1325 y0
= v
[0]; y1
= v
[1];
1327 y0
= v
[1]; y1
= v
[0];
1330 y1
= frame_context
.track
->PlayResY
; // y0=y1=0 means fullscreen scrolling
1331 render_context
.clip_y0
= y0
;
1332 render_context
.clip_y1
= y1
;
1333 render_context
.evt_type
= EVENT_VSCROLL
;
1334 render_context
.detect_collisions
= 0;
1340 * \brief partially reset render_context to style values
1341 * Works like {\r}: resets some style overrides
1343 static void reset_render_context(void)
1345 render_context
.c
[0] = render_context
.style
->PrimaryColour
;
1346 render_context
.c
[1] = render_context
.style
->SecondaryColour
;
1347 render_context
.c
[2] = render_context
.style
->OutlineColour
;
1348 render_context
.c
[3] = render_context
.style
->BackColour
;
1349 render_context
.font_size
= render_context
.style
->FontSize
;
1351 if (render_context
.family
)
1352 free(render_context
.family
);
1353 render_context
.family
= strdup(render_context
.style
->FontName
);
1354 render_context
.bold
= render_context
.style
->Bold
;
1355 render_context
.italic
= render_context
.style
->Italic
;
1359 render_context
.scale_x
= render_context
.style
->ScaleX
;
1360 render_context
.scale_y
= render_context
.style
->ScaleY
;
1361 render_context
.hspacing
= render_context
.style
->Spacing
;
1362 render_context
.be
= 0;
1363 render_context
.blur
= 0.0;
1364 render_context
.shadow
= render_context
.style
->Shadow
;
1365 render_context
.frx
= render_context
.fry
= 0.;
1366 render_context
.frz
= M_PI
* render_context
.style
->Angle
/ 180.;
1368 // FIXME: does not reset unsupported attributes.
1372 * \brief Start new event. Reset render_context.
1374 static void init_render_context(ass_event_t
* event
)
1376 render_context
.event
= event
;
1377 render_context
.style
= frame_context
.track
->styles
+ event
->Style
;
1379 reset_render_context();
1381 render_context
.evt_type
= EVENT_NORMAL
;
1382 render_context
.alignment
= render_context
.style
->Alignment
;
1383 render_context
.pos_x
= 0;
1384 render_context
.pos_y
= 0;
1385 render_context
.org_x
= 0;
1386 render_context
.org_y
= 0;
1387 render_context
.have_origin
= 0;
1388 render_context
.clip_x0
= 0;
1389 render_context
.clip_y0
= 0;
1390 render_context
.clip_x1
= frame_context
.track
->PlayResX
;
1391 render_context
.clip_y1
= frame_context
.track
->PlayResY
;
1392 render_context
.detect_collisions
= 1;
1393 render_context
.fade
= 0;
1394 render_context
.drawing_mode
= 0;
1395 render_context
.effect_type
= EF_NONE
;
1396 render_context
.effect_timing
= 0;
1397 render_context
.effect_skip_timing
= 0;
1399 apply_transition_effects(event
);
1402 static void free_render_context(void)
1407 * \brief Get normal and outline (border) glyphs
1408 * \param symbol ucs4 char
1409 * \param info out: struct filled with extracted data
1410 * \param advance subpixel shift vector used for cache lookup
1411 * Tries to get both glyphs from cache.
1412 * If they can't be found, gets a glyph from font face, generates outline with FT_Stroker,
1413 * and add them to cache.
1414 * The glyphs are returned in info->glyph and info->outline_glyph
1416 static void get_outline_glyph(int symbol
, glyph_info_t
* info
, FT_Vector
* advance
)
1419 glyph_hash_val_t
* val
;
1420 glyph_hash_key_t key
;
1421 key
.font
= render_context
.font
;
1422 key
.size
= render_context
.font_size
;
1424 key
.scale_x
= (render_context
.scale_x
* 0xFFFF);
1425 key
.scale_y
= (render_context
.scale_y
* 0xFFFF);
1426 key
.advance
= *advance
;
1427 key
.bold
= render_context
.bold
;
1428 key
.italic
= render_context
.italic
;
1429 key
.outline
= render_context
.border
* 0xFFFF;
1431 memset(info
, 0, sizeof(glyph_info_t
));
1433 val
= cache_find_glyph(&key
);
1435 FT_Glyph_Copy(val
->glyph
, &info
->glyph
);
1436 if (val
->outline_glyph
)
1437 FT_Glyph_Copy(val
->outline_glyph
, &info
->outline_glyph
);
1438 info
->bbox
= val
->bbox_scaled
;
1439 info
->advance
.x
= val
->advance
.x
;
1440 info
->advance
.y
= val
->advance
.y
;
1443 info
->glyph
= ass_font_get_glyph(frame_context
.ass_priv
->fontconfig_priv
, render_context
.font
, symbol
, global_settings
->hinting
);
1446 info
->advance
.x
= d16_to_d6(info
->glyph
->advance
.x
);
1447 info
->advance
.y
= d16_to_d6(info
->glyph
->advance
.y
);
1448 FT_Glyph_Get_CBox( info
->glyph
, FT_GLYPH_BBOX_PIXELS
, &info
->bbox
);
1450 if (render_context
.stroker
) {
1451 info
->outline_glyph
= info
->glyph
;
1452 error
= FT_Glyph_StrokeBorder( &(info
->outline_glyph
), render_context
.stroker
, 0 , 0 ); // don't destroy original
1454 mp_msg(MSGT_ASS
, MSGL_WARN
, MSGTR_LIBASS_FT_Glyph_Stroke_Error
, error
);
1458 memset(&v
, 0, sizeof(v
));
1459 FT_Glyph_Copy(info
->glyph
, &v
.glyph
);
1460 if (info
->outline_glyph
)
1461 FT_Glyph_Copy(info
->outline_glyph
, &v
.outline_glyph
);
1462 v
.advance
= info
->advance
;
1463 v
.bbox_scaled
= info
->bbox
;
1464 cache_add_glyph(&key
, &v
);
1468 static void transform_3d(FT_Vector shift
, FT_Glyph
* glyph
, FT_Glyph
* glyph2
, double frx
, double fry
, double frz
);
1471 * \brief Get bitmaps for a glyph
1472 * \param info glyph info
1473 * Tries to get glyph bitmaps from bitmap cache.
1474 * If they can't be found, they are generated by rotating and rendering the glyph.
1475 * After that, bitmaps are added to the cache.
1476 * They are returned in info->bm (glyph), info->bm_o (outline) and info->bm_s (shadow).
1478 static void get_bitmap_glyph(glyph_info_t
* info
)
1480 bitmap_hash_val_t
* val
;
1481 bitmap_hash_key_t
* key
= &info
->hash_key
;
1483 val
= cache_find_bitmap(key
);
1488 info
->bm_o
= val
->bm_o
;
1489 info
->bm_s
= val
->bm_s
;
1492 bitmap_hash_val_t hash_val
;
1494 info
->bm
= info
->bm_o
= info
->bm_s
= 0;
1495 if (info
->glyph
&& info
->symbol
!= '\n' && info
->symbol
!= 0) {
1496 // calculating rotation shift vector (from rotation origin to the glyph basepoint)
1497 shift
.x
= int_to_d6(info
->hash_key
.shift_x
);
1498 shift
.y
= int_to_d6(info
->hash_key
.shift_y
);
1500 transform_3d(shift
, &info
->glyph
, &info
->outline_glyph
, info
->frx
, info
->fry
, info
->frz
);
1503 error
= glyph_to_bitmap(ass_renderer
->synth_priv
,
1504 info
->glyph
, info
->outline_glyph
,
1505 &info
->bm
, &info
->bm_o
,
1506 &info
->bm_s
, info
->be
, info
->blur
* frame_context
.border_scale
);
1510 // add bitmaps to cache
1511 hash_val
.bm_o
= info
->bm_o
;
1512 hash_val
.bm
= info
->bm
;
1513 hash_val
.bm_s
= info
->bm_s
;
1514 cache_add_bitmap(&(info
->hash_key
), &hash_val
);
1517 // deallocate glyphs
1519 FT_Done_Glyph(info
->glyph
);
1520 if (info
->outline_glyph
)
1521 FT_Done_Glyph(info
->outline_glyph
);
1525 * This function goes through text_info and calculates text parameters.
1526 * The following text_info fields are filled:
1532 static void measure_text(void)
1534 int cur_line
= 0, max_asc
= 0, max_desc
= 0;
1536 text_info
.height
= 0;
1537 for (i
= 0; i
< text_info
.length
+ 1; ++i
) {
1538 if ((i
== text_info
.length
) || text_info
.glyphs
[i
].linebreak
) {
1539 text_info
.lines
[cur_line
].asc
= max_asc
;
1540 text_info
.lines
[cur_line
].desc
= max_desc
;
1541 text_info
.height
+= max_asc
+ max_desc
;
1543 max_asc
= max_desc
= 0;
1545 if (i
< text_info
.length
) {
1546 glyph_info_t
* cur
= text_info
.glyphs
+ i
;
1547 if (cur
->asc
> max_asc
)
1549 if (cur
->desc
> max_desc
)
1550 max_desc
= cur
->desc
;
1553 text_info
.height
+= (text_info
.n_lines
- 1) * double_to_d6(global_settings
->line_spacing
);
1557 * \brief rearrange text between lines
1558 * \param max_text_width maximal text line width in pixels
1559 * The algo is similar to the one in libvo/sub.c:
1560 * 1. Place text, wrapping it when current line is full
1561 * 2. Try moving words from the end of a line to the beginning of the next one while it reduces
1562 * the difference in lengths between this two lines.
1563 * The result may not be optimal, but usually is good enough.
1565 static void wrap_lines_smart(int max_text_width
)
1568 glyph_info_t
*cur
, *s1
, *e1
, *s2
, *s3
, *w
;
1577 text_info
.n_lines
= 1;
1579 s1
= text_info
.glyphs
; // current line start
1580 for (i
= 0; i
< text_info
.length
; ++i
) {
1581 int break_at
, s_offset
, len
;
1582 cur
= text_info
.glyphs
+ i
;
1584 s_offset
= s1
->bbox
.xMin
+ s1
->pos
.x
;
1585 len
= (cur
->bbox
.xMax
+ cur
->pos
.x
) - s_offset
;
1587 if (cur
->symbol
== '\n') {
1590 mp_msg(MSGT_ASS
, MSGL_DBG2
, "forced line break at %d\n", break_at
);
1593 if (len
>= max_text_width
) {
1595 break_at
= last_space
;
1600 mp_msg(MSGT_ASS
, MSGL_DBG2
, "overfill at %d\n", i
);
1601 mp_msg(MSGT_ASS
, MSGL_DBG2
, "line break at %d\n", break_at
);
1604 if (break_at
!= -1) {
1605 // need to use one more line
1606 // marking break_at+1 as start of a new line
1607 int lead
= break_at
+ 1; // the first symbol of the new line
1608 if (text_info
.n_lines
>= MAX_LINES
) {
1610 // no more linebreaks
1611 for (j
= lead
; j
< text_info
.length
; ++j
)
1612 text_info
.glyphs
[j
].linebreak
= 0;
1615 if (lead
< text_info
.length
)
1616 text_info
.glyphs
[lead
].linebreak
= break_type
;
1618 s1
= text_info
.glyphs
+ lead
;
1619 s_offset
= s1
->bbox
.xMin
+ s1
->pos
.x
;
1620 text_info
.n_lines
++;
1623 if (cur
->symbol
== ' ')
1626 // make sure the hard linebreak is not forgotten when
1627 // there was a new soft linebreak just inserted
1628 if (cur
->symbol
== '\n' && break_type
== 1)
1631 #define DIFF(x,y) (((x) < (y)) ? (y - x) : (x - y))
1635 w
= s3
= text_info
.glyphs
;
1637 for (i
= 0; i
<= text_info
.length
; ++i
) {
1638 cur
= text_info
.glyphs
+ i
;
1639 if ((i
== text_info
.length
) || cur
->linebreak
) {
1643 if (s1
&& (s2
->linebreak
== 1)) { // have at least 2 lines, and linebreak is 'soft'
1644 int l1
, l2
, l1_new
, l2_new
;
1647 do { --w
; } while ((w
> s1
) && (w
->symbol
== ' '));
1648 while ((w
> s1
) && (w
->symbol
!= ' ')) { --w
; }
1650 while ((e1
> s1
) && (e1
->symbol
== ' ')) { --e1
; }
1651 if (w
->symbol
== ' ') ++w
;
1653 l1
= ((s2
-1)->bbox
.xMax
+ (s2
-1)->pos
.x
) - (s1
->bbox
.xMin
+ s1
->pos
.x
);
1654 l2
= ((s3
-1)->bbox
.xMax
+ (s3
-1)->pos
.x
) - (s2
->bbox
.xMin
+ s2
->pos
.x
);
1655 l1_new
= (e1
->bbox
.xMax
+ e1
->pos
.x
) - (s1
->bbox
.xMin
+ s1
->pos
.x
);
1656 l2_new
= ((s3
-1)->bbox
.xMax
+ (s3
-1)->pos
.x
) - (w
->bbox
.xMin
+ w
->pos
.x
);
1658 if (DIFF(l1_new
, l2_new
) < DIFF(l1
, l2
)) {
1665 if (i
== text_info
.length
)
1670 assert(text_info
.n_lines
>= 1);
1678 for (i
= 0; i
< text_info
.length
; ++i
) {
1679 cur
= text_info
.glyphs
+ i
;
1680 if (cur
->linebreak
) {
1681 int height
= text_info
.lines
[cur_line
- 1].desc
+ text_info
.lines
[cur_line
].asc
;
1683 pen_shift_x
= - cur
->pos
.x
;
1684 pen_shift_y
+= d6_to_int(height
+ double_to_d6(global_settings
->line_spacing
));
1685 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
);
1687 cur
->pos
.x
+= pen_shift_x
;
1688 cur
->pos
.y
+= pen_shift_y
;
1693 * \brief determine karaoke effects
1694 * Karaoke effects cannot be calculated during parse stage (get_next_char()),
1695 * so they are done in a separate step.
1696 * Parse stage: when karaoke style override is found, its parameters are stored in the next glyph's
1697 * (the first glyph of the karaoke word)'s effect_type and effect_timing.
1699 * 1. sets effect_type for all glyphs in the word (_karaoke_ word)
1700 * 2. sets effect_timing for all glyphs to x coordinate of the border line between the left and right karaoke parts
1701 * (left part is filled with PrimaryColour, right one - with SecondaryColour).
1703 static void process_karaoke_effects(void)
1705 glyph_info_t
*cur
, *cur2
;
1706 glyph_info_t
*s1
, *e1
; // start and end of the current word
1707 glyph_info_t
*s2
; // start of the next word
1709 int timing
; // current timing
1710 int tm_start
, tm_end
; // timings at start and end of the current word
1716 tm_current
= frame_context
.time
- render_context
.event
->Start
;
1719 for (i
= 0; i
<= text_info
.length
; ++i
) {
1720 cur
= text_info
.glyphs
+ i
;
1721 if ((i
== text_info
.length
) || (cur
->effect_type
!= EF_NONE
)) {
1726 tm_start
= timing
+ s1
->effect_skip_timing
;
1727 tm_end
= tm_start
+ s1
->effect_timing
;
1731 for (cur2
= s1
; cur2
<= e1
; ++cur2
) {
1732 x_start
= FFMIN(x_start
, cur2
->bbox
.xMin
+ cur2
->pos
.x
);
1733 x_end
= FFMAX(x_end
, cur2
->bbox
.xMax
+ cur2
->pos
.x
);
1736 dt
= (tm_current
- tm_start
);
1737 if ((s1
->effect_type
== EF_KARAOKE
) || (s1
->effect_type
== EF_KARAOKE_KO
)) {
1742 } else if (s1
->effect_type
== EF_KARAOKE_KF
) {
1743 dt
/= (tm_end
- tm_start
);
1744 x
= x_start
+ (x_end
- x_start
) * dt
;
1746 mp_msg(MSGT_ASS
, MSGL_ERR
, MSGTR_LIBASS_UnknownEffectType_InternalError
);
1750 for (cur2
= s1
; cur2
<= e1
; ++cur2
) {
1751 cur2
->effect_type
= s1
->effect_type
;
1752 cur2
->effect_timing
= x
- cur2
->pos
.x
;
1760 * \brief Calculate base point for positioning and rotation
1761 * \param bbox text bbox
1762 * \param alignment alignment
1763 * \param bx, by out: base point coordinates
1765 static void get_base_point(FT_BBox bbox
, int alignment
, int* bx
, int* by
)
1767 const int halign
= alignment
& 3;
1768 const int valign
= alignment
& 12;
1775 *bx
= (bbox
.xMax
+ bbox
.xMin
) / 2;
1787 *by
= (bbox
.yMax
+ bbox
.yMin
) / 2;
1796 * \brief Multiply 4-vector by 4-matrix
1798 * \param m 4-matrix]
1799 * \param b out: 4-vector
1800 * Calculates a * m and stores result in b
1802 static inline void transform_point_3d(double *a
, double *m
, double *b
)
1804 b
[0] = a
[0] * m
[0] + a
[1] * m
[4] + a
[2] * m
[8] + a
[3] * m
[12];
1805 b
[1] = a
[0] * m
[1] + a
[1] * m
[5] + a
[2] * m
[9] + a
[3] * m
[13];
1806 b
[2] = a
[0] * m
[2] + a
[1] * m
[6] + a
[2] * m
[10] + a
[3] * m
[14];
1807 b
[3] = a
[0] * m
[3] + a
[1] * m
[7] + a
[2] * m
[11] + a
[3] * m
[15];
1811 * \brief Apply 3d transformation to a vector
1812 * \param v FreeType vector (2d)
1814 * Transforms v by m, projects the result back to the screen plane
1815 * Result is returned in v.
1817 static inline void transform_vector_3d(FT_Vector
* v
, double *m
) {
1818 const double camera
= 2500 * frame_context
.border_scale
; // camera distance
1819 const double cutoff_z
= 10.;
1821 a
[0] = d6_to_double(v
->x
);
1822 a
[1] = d6_to_double(v
->y
);
1825 transform_point_3d(a
, m
, b
);
1826 /* Apply perspective projection with the following matrix:
1831 where 2500 is camera distance, 8 - z-axis scale.
1832 Camera is always located in (org_x, org_y, -2500). This means
1833 that different subtitle events can be displayed at the same time
1834 using different cameras. */
1837 b
[3] = 8 * b
[2] + camera
;
1838 if (b
[3] < cutoff_z
)
1840 v
->x
= double_to_d6(b
[0] / b
[3]);
1841 v
->y
= double_to_d6(b
[1] / b
[3]);
1845 * \brief Apply 3d transformation to a glyph
1846 * \param glyph FreeType glyph
1848 * Transforms glyph by m, projects the result back to the screen plane
1849 * Result is returned in glyph.
1851 static inline void transform_glyph_3d(FT_Glyph glyph
, double *m
, FT_Vector shift
) {
1853 FT_Outline
* outline
= &((FT_OutlineGlyph
)glyph
)->outline
;
1854 FT_Vector
* p
= outline
->points
;
1856 for (i
=0; i
<outline
->n_points
; i
++) {
1859 transform_vector_3d(p
+ i
, m
);
1864 //transform_vector_3d(&glyph->advance, m);
1868 * \brief Apply 3d transformation to several objects
1869 * \param shift FreeType vector
1870 * \param glyph FreeType glyph
1871 * \param glyph2 FreeType glyph
1872 * \param frx x-axis rotation angle
1873 * \param fry y-axis rotation angle
1874 * \param frz z-axis rotation angle
1875 * Rotates both glyphs by frx, fry and frz. Shift vector is added before rotation and subtracted after it.
1877 static void transform_3d(FT_Vector shift
, FT_Glyph
* glyph
, FT_Glyph
* glyph2
, double frx
, double fry
, double frz
)
1879 fry
= - fry
; // FreeType's y axis goes in the opposite direction
1880 if (frx
!= 0. || fry
!= 0. || frz
!= 0.) {
1882 double sx
= sin(frx
);
1883 double sy
= sin(fry
);
1884 double sz
= sin(frz
);
1885 double cx
= cos(frx
);
1886 double cy
= cos(fry
);
1887 double cz
= cos(frz
);
1888 m
[0] = cy
* cz
; m
[1] = cy
*sz
; m
[2] = -sy
; m
[3] = 0.0;
1889 m
[4] = -cx
*sz
+ sx
*sy
*cz
; m
[5] = cx
*cz
+ sx
*sy
*sz
; m
[6] = sx
*cy
; m
[7] = 0.0;
1890 m
[8] = sx
*sz
+ cx
*sy
*cz
; m
[9] = -sx
*cz
+ cx
*sy
*sz
; m
[10] = cx
*cy
; m
[11] = 0.0;
1891 m
[12] = 0.0; m
[13] = 0.0; m
[14] = 0.0; m
[15] = 1.0;
1893 if (glyph
&& *glyph
)
1894 transform_glyph_3d(*glyph
, m
, shift
);
1896 if (glyph2
&& *glyph2
)
1897 transform_glyph_3d(*glyph2
, m
, shift
);
1902 * \brief Main ass rendering function, glues everything together
1903 * \param event event to render
1904 * Process event, appending resulting ass_image_t's to images_root.
1906 static int ass_render_event(ass_event_t
* event
, event_images_t
* event_images
)
1916 int MarginL
, MarginR
, MarginV
;
1918 int alignment
, halign
, valign
;
1919 int device_x
= 0, device_y
= 0;
1921 if (event
->Style
>= frame_context
.track
->n_styles
) {
1922 mp_msg(MSGT_ASS
, MSGL_WARN
, MSGTR_LIBASS_NoStyleFound
);
1926 mp_msg(MSGT_ASS
, MSGL_WARN
, MSGTR_LIBASS_EmptyEvent
);
1930 init_render_context(event
);
1932 text_info
.length
= 0;
1940 // get next char, executing style override
1941 // this affects render_context
1943 code
= get_next_char(&p
);
1944 } while (code
&& render_context
.drawing_mode
); // skip everything in drawing mode
1946 // face could have been changed in get_next_char
1947 if (!render_context
.font
) {
1948 free_render_context();
1955 if (text_info
.length
>= MAX_GLYPHS
) {
1956 mp_msg(MSGT_ASS
, MSGL_WARN
, MSGTR_LIBASS_MAX_GLYPHS_Reached
,
1957 (int)(event
- frame_context
.track
->events
), event
->Start
, event
->Duration
, event
->Text
);
1961 if ( previous
&& code
) {
1963 delta
= ass_font_get_kerning(render_context
.font
, previous
, code
);
1964 pen
.x
+= delta
.x
* render_context
.scale_x
;
1965 pen
.y
+= delta
.y
* render_context
.scale_y
;
1968 shift
.x
= pen
.x
& SUBPIXEL_MASK
;
1969 shift
.y
= pen
.y
& SUBPIXEL_MASK
;
1971 if (render_context
.evt_type
== EVENT_POSITIONED
) {
1972 shift
.x
+= double_to_d6(x2scr_pos(render_context
.pos_x
)) & SUBPIXEL_MASK
;
1973 shift
.y
-= double_to_d6(y2scr_pos(render_context
.pos_y
)) & SUBPIXEL_MASK
;
1976 ass_font_set_transform(render_context
.font
,
1977 render_context
.scale_x
* frame_context
.font_scale_x
,
1978 render_context
.scale_y
,
1981 get_outline_glyph(code
, text_info
.glyphs
+ text_info
.length
, &shift
);
1983 text_info
.glyphs
[text_info
.length
].pos
.x
= pen
.x
>> 6;
1984 text_info
.glyphs
[text_info
.length
].pos
.y
= pen
.y
>> 6;
1986 pen
.x
+= text_info
.glyphs
[text_info
.length
].advance
.x
;
1987 pen
.x
+= double_to_d6(render_context
.hspacing
);
1988 pen
.y
+= text_info
.glyphs
[text_info
.length
].advance
.y
;
1992 text_info
.glyphs
[text_info
.length
].symbol
= code
;
1993 text_info
.glyphs
[text_info
.length
].linebreak
= 0;
1994 for (i
= 0; i
< 4; ++i
) {
1995 uint32_t clr
= render_context
.c
[i
];
1996 change_alpha(&clr
, mult_alpha(_a(clr
), render_context
.fade
), 1.);
1997 text_info
.glyphs
[text_info
.length
].c
[i
] = clr
;
1999 text_info
.glyphs
[text_info
.length
].effect_type
= render_context
.effect_type
;
2000 text_info
.glyphs
[text_info
.length
].effect_timing
= render_context
.effect_timing
;
2001 text_info
.glyphs
[text_info
.length
].effect_skip_timing
= render_context
.effect_skip_timing
;
2002 text_info
.glyphs
[text_info
.length
].be
= render_context
.be
;
2003 text_info
.glyphs
[text_info
.length
].blur
= render_context
.blur
;
2004 text_info
.glyphs
[text_info
.length
].shadow
= render_context
.shadow
;
2005 text_info
.glyphs
[text_info
.length
].frx
= render_context
.frx
;
2006 text_info
.glyphs
[text_info
.length
].fry
= render_context
.fry
;
2007 text_info
.glyphs
[text_info
.length
].frz
= render_context
.frz
;
2008 ass_font_get_asc_desc(render_context
.font
, code
,
2009 &text_info
.glyphs
[text_info
.length
].asc
,
2010 &text_info
.glyphs
[text_info
.length
].desc
);
2011 text_info
.glyphs
[text_info
.length
].asc
*= render_context
.scale_y
;
2012 text_info
.glyphs
[text_info
.length
].desc
*= render_context
.scale_y
;
2014 // fill bitmap_hash_key
2015 text_info
.glyphs
[text_info
.length
].hash_key
.font
= render_context
.font
;
2016 text_info
.glyphs
[text_info
.length
].hash_key
.size
= render_context
.font_size
;
2017 text_info
.glyphs
[text_info
.length
].hash_key
.outline
= render_context
.border
* 0xFFFF;
2018 text_info
.glyphs
[text_info
.length
].hash_key
.scale_x
= render_context
.scale_x
* 0xFFFF;
2019 text_info
.glyphs
[text_info
.length
].hash_key
.scale_y
= render_context
.scale_y
* 0xFFFF;
2020 text_info
.glyphs
[text_info
.length
].hash_key
.frx
= render_context
.frx
* 0xFFFF;
2021 text_info
.glyphs
[text_info
.length
].hash_key
.fry
= render_context
.fry
* 0xFFFF;
2022 text_info
.glyphs
[text_info
.length
].hash_key
.frz
= render_context
.frz
* 0xFFFF;
2023 text_info
.glyphs
[text_info
.length
].hash_key
.bold
= render_context
.bold
;
2024 text_info
.glyphs
[text_info
.length
].hash_key
.italic
= render_context
.italic
;
2025 text_info
.glyphs
[text_info
.length
].hash_key
.ch
= code
;
2026 text_info
.glyphs
[text_info
.length
].hash_key
.advance
= shift
;
2027 text_info
.glyphs
[text_info
.length
].hash_key
.be
= render_context
.be
;
2028 text_info
.glyphs
[text_info
.length
].hash_key
.blur
= render_context
.blur
;
2032 render_context
.effect_type
= EF_NONE
;
2033 render_context
.effect_timing
= 0;
2034 render_context
.effect_skip_timing
= 0;
2037 if (text_info
.length
== 0) {
2038 // no valid symbols in the event; this can be smth like {comment}
2039 free_render_context();
2043 // depends on glyph x coordinates being monotonous, so it should be done before line wrap
2044 process_karaoke_effects();
2047 alignment
= render_context
.alignment
;
2048 halign
= alignment
& 3;
2049 valign
= alignment
& 12;
2051 MarginL
= (event
->MarginL
) ? event
->MarginL
: render_context
.style
->MarginL
;
2052 MarginR
= (event
->MarginR
) ? event
->MarginR
: render_context
.style
->MarginR
;
2053 MarginV
= (event
->MarginV
) ? event
->MarginV
: render_context
.style
->MarginV
;
2055 if (render_context
.evt_type
!= EVENT_HSCROLL
) {
2058 // calculate max length of a line
2059 max_text_width
= x2scr(frame_context
.track
->PlayResX
- MarginR
) - x2scr(MarginL
);
2061 // rearrange text in several lines
2062 wrap_lines_smart(max_text_width
);
2066 for (i
= 1; i
< text_info
.length
+ 1; ++i
) { // (text_info.length + 1) is the end of the last line
2067 if ((i
== text_info
.length
) || text_info
.glyphs
[i
].linebreak
) {
2068 int width
, shift
= 0;
2069 glyph_info_t
* first_glyph
= text_info
.glyphs
+ last_break
+ 1;
2070 glyph_info_t
* last_glyph
= text_info
.glyphs
+ i
- 1;
2072 while ((last_glyph
> first_glyph
) && ((last_glyph
->symbol
== '\n') || (last_glyph
->symbol
== 0)))
2075 width
= last_glyph
->pos
.x
+ d6_to_int(last_glyph
->advance
.x
) - first_glyph
->pos
.x
;
2076 if (halign
== HALIGN_LEFT
) { // left aligned, no action
2078 } else if (halign
== HALIGN_RIGHT
) { // right aligned
2079 shift
= max_text_width
- width
;
2080 } else if (halign
== HALIGN_CENTER
) { // centered
2081 shift
= (max_text_width
- width
) / 2;
2083 for (j
= last_break
+ 1; j
< i
; ++j
) {
2084 text_info
.glyphs
[j
].pos
.x
+= shift
;
2089 } else { // render_context.evt_type == EVENT_HSCROLL
2093 // determing text bounding box
2094 compute_string_bbox(&text_info
, &bbox
);
2096 // determine device coordinates for text
2098 // x coordinate for everything except positioned events
2099 if (render_context
.evt_type
== EVENT_NORMAL
||
2100 render_context
.evt_type
== EVENT_VSCROLL
) {
2101 device_x
= x2scr(MarginL
);
2102 } else if (render_context
.evt_type
== EVENT_HSCROLL
) {
2103 if (render_context
.scroll_direction
== SCROLL_RL
)
2104 device_x
= x2scr(frame_context
.track
->PlayResX
- render_context
.scroll_shift
);
2105 else if (render_context
.scroll_direction
== SCROLL_LR
)
2106 device_x
= x2scr(render_context
.scroll_shift
) - (bbox
.xMax
- bbox
.xMin
);
2109 // y coordinate for everything except positioned events
2110 if (render_context
.evt_type
== EVENT_NORMAL
||
2111 render_context
.evt_type
== EVENT_HSCROLL
) {
2112 if (valign
== VALIGN_TOP
) { // toptitle
2113 device_y
= y2scr_top(MarginV
) + d6_to_int(text_info
.lines
[0].asc
);
2114 } else if (valign
== VALIGN_CENTER
) { // midtitle
2115 int scr_y
= y2scr(frame_context
.track
->PlayResY
/ 2);
2116 device_y
= scr_y
- (bbox
.yMax
- bbox
.yMin
) / 2;
2117 } else { // subtitle
2119 if (valign
!= VALIGN_SUB
)
2120 mp_msg(MSGT_ASS
, MSGL_V
, "Invalid valign, supposing 0 (subtitle)\n");
2121 scr_y
= y2scr_sub(frame_context
.track
->PlayResY
- MarginV
);
2123 device_y
-= d6_to_int(text_info
.height
);
2124 device_y
+= d6_to_int(text_info
.lines
[0].asc
);
2126 } else if (render_context
.evt_type
== EVENT_VSCROLL
) {
2127 if (render_context
.scroll_direction
== SCROLL_TB
)
2128 device_y
= y2scr(render_context
.clip_y0
+ render_context
.scroll_shift
) - (bbox
.yMax
- bbox
.yMin
);
2129 else if (render_context
.scroll_direction
== SCROLL_BT
)
2130 device_y
= y2scr(render_context
.clip_y1
- render_context
.scroll_shift
);
2133 // positioned events are totally different
2134 if (render_context
.evt_type
== EVENT_POSITIONED
) {
2137 mp_msg(MSGT_ASS
, MSGL_DBG2
, "positioned event at %f, %f\n", render_context
.pos_x
, render_context
.pos_y
);
2138 get_base_point(bbox
, alignment
, &base_x
, &base_y
);
2139 device_x
= x2scr_pos(render_context
.pos_x
) - base_x
;
2140 device_y
= y2scr_pos(render_context
.pos_y
) - base_y
;
2143 // fix clip coordinates (they depend on alignment)
2144 render_context
.clip_x0
= x2scr(render_context
.clip_x0
);
2145 render_context
.clip_x1
= x2scr(render_context
.clip_x1
);
2146 if (render_context
.evt_type
== EVENT_NORMAL
||
2147 render_context
.evt_type
== EVENT_HSCROLL
||
2148 render_context
.evt_type
== EVENT_VSCROLL
) {
2149 if (valign
== VALIGN_TOP
) {
2150 render_context
.clip_y0
= y2scr_top(render_context
.clip_y0
);
2151 render_context
.clip_y1
= y2scr_top(render_context
.clip_y1
);
2152 } else if (valign
== VALIGN_CENTER
) {
2153 render_context
.clip_y0
= y2scr(render_context
.clip_y0
);
2154 render_context
.clip_y1
= y2scr(render_context
.clip_y1
);
2155 } else if (valign
== VALIGN_SUB
) {
2156 render_context
.clip_y0
= y2scr_sub(render_context
.clip_y0
);
2157 render_context
.clip_y1
= y2scr_sub(render_context
.clip_y1
);
2159 } else if (render_context
.evt_type
== EVENT_POSITIONED
) {
2160 render_context
.clip_y0
= y2scr(render_context
.clip_y0
);
2161 render_context
.clip_y1
= y2scr(render_context
.clip_y1
);
2164 // calculate rotation parameters
2168 if (render_context
.have_origin
) {
2169 center
.x
= x2scr(render_context
.org_x
);
2170 center
.y
= y2scr(render_context
.org_y
);
2173 get_base_point(bbox
, alignment
, &bx
, &by
);
2174 center
.x
= device_x
+ bx
;
2175 center
.y
= device_y
+ by
;
2178 for (i
= 0; i
< text_info
.length
; ++i
) {
2179 glyph_info_t
* info
= text_info
.glyphs
+ i
;
2181 if (info
->hash_key
.frx
|| info
->hash_key
.fry
|| info
->hash_key
.frz
) {
2182 info
->hash_key
.shift_x
= info
->pos
.x
+ device_x
- center
.x
;
2183 info
->hash_key
.shift_y
= - (info
->pos
.y
+ device_y
- center
.y
);
2185 info
->hash_key
.shift_x
= 0;
2186 info
->hash_key
.shift_y
= 0;
2191 // convert glyphs to bitmaps
2192 for (i
= 0; i
< text_info
.length
; ++i
)
2193 get_bitmap_glyph(text_info
.glyphs
+ i
);
2195 event_images
->top
= device_y
- d6_to_int(text_info
.lines
[0].asc
);
2196 event_images
->height
= d6_to_int(text_info
.height
);
2197 event_images
->detect_collisions
= render_context
.detect_collisions
;
2198 event_images
->shift_direction
= (valign
== VALIGN_TOP
) ? 1 : -1;
2199 event_images
->event
= event
;
2200 event_images
->imgs
= render_text(&text_info
, device_x
, device_y
);
2202 free_render_context();
2208 * \brief deallocate image list
2209 * \param img list pointer
2211 void ass_free_images(ass_image_t
* img
)
2214 ass_image_t
* next
= img
->next
;
2220 static void ass_reconfigure(ass_renderer_t
* priv
)
2222 priv
->render_id
= ++last_render_id
;
2223 ass_glyph_cache_reset();
2224 ass_bitmap_cache_reset();
2225 ass_composite_cache_reset();
2226 ass_free_images(priv
->prev_images_root
);
2227 priv
->prev_images_root
= 0;
2230 void ass_set_frame_size(ass_renderer_t
* priv
, int w
, int h
)
2232 if (priv
->settings
.frame_width
!= w
|| priv
->settings
.frame_height
!= h
) {
2233 priv
->settings
.frame_width
= w
;
2234 priv
->settings
.frame_height
= h
;
2235 if (priv
->settings
.aspect
== 0.)
2236 priv
->settings
.aspect
= ((double)w
) / h
;
2237 ass_reconfigure(priv
);
2241 void ass_set_margins(ass_renderer_t
* priv
, int t
, int b
, int l
, int r
)
2243 if (priv
->settings
.left_margin
!= l
||
2244 priv
->settings
.right_margin
!= r
||
2245 priv
->settings
.top_margin
!= t
||
2246 priv
->settings
.bottom_margin
!= b
) {
2247 priv
->settings
.left_margin
= l
;
2248 priv
->settings
.right_margin
= r
;
2249 priv
->settings
.top_margin
= t
;
2250 priv
->settings
.bottom_margin
= b
;
2251 ass_reconfigure(priv
);
2255 void ass_set_use_margins(ass_renderer_t
* priv
, int use
)
2257 priv
->settings
.use_margins
= use
;
2260 void ass_set_aspect_ratio(ass_renderer_t
* priv
, double ar
)
2262 if (priv
->settings
.aspect
!= ar
) {
2263 priv
->settings
.aspect
= ar
;
2264 ass_reconfigure(priv
);
2268 void ass_set_font_scale(ass_renderer_t
* priv
, double font_scale
)
2270 if (priv
->settings
.font_size_coeff
!= font_scale
) {
2271 priv
->settings
.font_size_coeff
= font_scale
;
2272 ass_reconfigure(priv
);
2276 void ass_set_hinting(ass_renderer_t
* priv
, ass_hinting_t ht
)
2278 if (priv
->settings
.hinting
!= ht
) {
2279 priv
->settings
.hinting
= ht
;
2280 ass_reconfigure(priv
);
2284 void ass_set_line_spacing(ass_renderer_t
* priv
, double line_spacing
)
2286 priv
->settings
.line_spacing
= line_spacing
;
2289 static int ass_set_fonts_(ass_renderer_t
* priv
, const char* default_font
, const char* default_family
, int fc
)
2291 if (priv
->settings
.default_font
)
2292 free(priv
->settings
.default_font
);
2293 if (priv
->settings
.default_family
)
2294 free(priv
->settings
.default_family
);
2296 priv
->settings
.default_font
= default_font
? strdup(default_font
) : 0;
2297 priv
->settings
.default_family
= default_family
? strdup(default_family
) : 0;
2299 if (priv
->fontconfig_priv
)
2300 fontconfig_done(priv
->fontconfig_priv
);
2301 priv
->fontconfig_priv
= fontconfig_init(priv
->library
, priv
->ftlibrary
, default_family
, default_font
, fc
);
2303 return !!priv
->fontconfig_priv
;
2306 int ass_set_fonts(ass_renderer_t
* priv
, const char* default_font
, const char* default_family
)
2308 return ass_set_fonts_(priv
, default_font
, default_family
, 1);
2311 int ass_set_fonts_nofc(ass_renderer_t
* priv
, const char* default_font
, const char* default_family
)
2313 return ass_set_fonts_(priv
, default_font
, default_family
, 0);
2317 * \brief Start a new frame
2319 static int ass_start_frame(ass_renderer_t
*priv
, ass_track_t
* track
, long long now
)
2321 ass_renderer
= priv
;
2322 global_settings
= &priv
->settings
;
2324 if (!priv
->settings
.frame_width
&& !priv
->settings
.frame_height
)
2325 return 1; // library not initialized
2327 if (track
->n_events
== 0)
2328 return 1; // nothing to do
2330 frame_context
.ass_priv
= priv
;
2331 frame_context
.width
= global_settings
->frame_width
;
2332 frame_context
.height
= global_settings
->frame_height
;
2333 frame_context
.orig_width
= global_settings
->frame_width
- global_settings
->left_margin
- global_settings
->right_margin
;
2334 frame_context
.orig_height
= global_settings
->frame_height
- global_settings
->top_margin
- global_settings
->bottom_margin
;
2335 frame_context
.orig_width_nocrop
= global_settings
->frame_width
-
2336 FFMAX(global_settings
->left_margin
, 0) -
2337 FFMAX(global_settings
->right_margin
, 0);
2338 frame_context
.orig_height_nocrop
= global_settings
->frame_height
-
2339 FFMAX(global_settings
->top_margin
, 0) -
2340 FFMAX(global_settings
->bottom_margin
, 0);
2341 frame_context
.track
= track
;
2342 frame_context
.time
= now
;
2344 ass_lazy_track_init();
2346 frame_context
.font_scale
= global_settings
->font_size_coeff
*
2347 frame_context
.orig_height
/ frame_context
.track
->PlayResY
;
2348 if (frame_context
.track
->ScaledBorderAndShadow
)
2349 frame_context
.border_scale
= ((double)frame_context
.orig_height
) / frame_context
.track
->PlayResY
;
2351 frame_context
.border_scale
= 1.;
2353 frame_context
.font_scale_x
= 1.;
2355 priv
->prev_images_root
= priv
->images_root
;
2356 priv
->images_root
= 0;
2361 static int cmp_event_layer(const void* p1
, const void* p2
)
2363 ass_event_t
* e1
= ((event_images_t
*)p1
)->event
;
2364 ass_event_t
* e2
= ((event_images_t
*)p2
)->event
;
2365 if (e1
->Layer
< e2
->Layer
)
2367 if (e1
->Layer
> e2
->Layer
)
2369 if (e1
->ReadOrder
< e2
->ReadOrder
)
2371 if (e1
->ReadOrder
> e2
->ReadOrder
)
2376 #define MAX_EVENTS 100
2378 static render_priv_t
* get_render_priv(ass_event_t
* event
)
2380 if (!event
->render_priv
)
2381 event
->render_priv
= calloc(1, sizeof(render_priv_t
));
2382 // FIXME: check render_id
2383 if (ass_renderer
->render_id
!= event
->render_priv
->render_id
) {
2384 memset(event
->render_priv
, 0, sizeof(render_priv_t
));
2385 event
->render_priv
->render_id
= ass_renderer
->render_id
;
2387 return event
->render_priv
;
2390 typedef struct segment_s
{
2391 int a
, b
; // top and height
2394 static int overlap(segment_t
* s1
, segment_t
* s2
)
2396 if (s1
->a
>= s2
->b
|| s2
->a
>= s1
->b
)
2401 static int cmp_segment(const void* p1
, const void* p2
)
2403 return ((segment_t
*)p1
)->a
- ((segment_t
*)p2
)->a
;
2406 static void shift_event(event_images_t
* ei
, int shift
)
2408 ass_image_t
* cur
= ei
->imgs
;
2410 cur
->dst_y
+= shift
;
2411 // clip top and bottom
2412 if (cur
->dst_y
< 0) {
2413 int clip
= - cur
->dst_y
;
2415 cur
->bitmap
+= clip
* cur
->stride
;
2418 if (cur
->dst_y
+ cur
->h
>= frame_context
.height
) {
2419 int clip
= cur
->dst_y
+ cur
->h
- frame_context
.height
;
2431 // dir: 1 - move down
2433 static int fit_segment(segment_t
* s
, segment_t
* fixed
, int* cnt
, int dir
)
2438 if (dir
== 1) // move down
2439 for (i
= 0; i
< *cnt
; ++i
) {
2440 if (s
->b
+ shift
<= fixed
[i
].a
|| s
->a
+ shift
>= fixed
[i
].b
)
2442 shift
= fixed
[i
].b
- s
->a
;
2444 else // dir == -1, move up
2445 for (i
= *cnt
-1; i
>= 0; --i
) {
2446 if (s
->b
+ shift
<= fixed
[i
].a
|| s
->a
+ shift
>= fixed
[i
].b
)
2448 shift
= fixed
[i
].a
- s
->b
;
2451 fixed
[*cnt
].a
= s
->a
+ shift
;
2452 fixed
[*cnt
].b
= s
->b
+ shift
;
2454 qsort(fixed
, *cnt
, sizeof(segment_t
), cmp_segment
);
2459 static void fix_collisions(event_images_t
* imgs
, int cnt
)
2461 segment_t used
[MAX_EVENTS
];
2465 // fill used[] with fixed events
2466 for (i
= 0; i
< cnt
; ++i
) {
2467 render_priv_t
* priv
;
2468 if (!imgs
[i
].detect_collisions
) continue;
2469 priv
= get_render_priv(imgs
[i
].event
);
2470 if (priv
->height
> 0) { // it's a fixed event
2473 s
.b
= priv
->top
+ priv
->height
;
2474 if (priv
->height
!= imgs
[i
].height
) { // no, it's not
2475 mp_msg(MSGT_ASS
, MSGL_WARN
, MSGTR_LIBASS_EventHeightHasChanged
);
2479 for (j
= 0; j
< cnt_used
; ++j
)
2480 if (overlap(&s
, used
+ j
)) { // no, it's not
2484 if (priv
->height
> 0) { // still a fixed event
2485 used
[cnt_used
].a
= priv
->top
;
2486 used
[cnt_used
].b
= priv
->top
+ priv
->height
;
2488 shift_event(imgs
+ i
, priv
->top
- imgs
[i
].top
);
2492 qsort(used
, cnt_used
, sizeof(segment_t
), cmp_segment
);
2494 // try to fit other events in free spaces
2495 for (i
= 0; i
< cnt
; ++i
) {
2496 render_priv_t
* priv
;
2497 if (!imgs
[i
].detect_collisions
) continue;
2498 priv
= get_render_priv(imgs
[i
].event
);
2499 if (priv
->height
== 0) { // not a fixed event
2503 s
.b
= imgs
[i
].top
+ imgs
[i
].height
;
2504 shift
= fit_segment(&s
, used
, &cnt_used
, imgs
[i
].shift_direction
);
2505 if (shift
) shift_event(imgs
+ i
, shift
);
2507 priv
->top
= imgs
[i
].top
;
2508 priv
->height
= imgs
[i
].height
;
2515 * \brief compare two images
2516 * \param i1 first image
2517 * \param i2 second image
2518 * \return 0 if identical, 1 if different positions, 2 if different content
2520 int ass_image_compare(ass_image_t
*i1
, ass_image_t
*i2
)
2522 if (i1
->w
!= i2
->w
) return 2;
2523 if (i1
->h
!= i2
->h
) return 2;
2524 if (i1
->stride
!= i2
->stride
) return 2;
2525 if (i1
->color
!= i2
->color
) return 2;
2526 if (i1
->bitmap
!= i2
->bitmap
)
2528 if (i1
->dst_x
!= i2
->dst_x
) return 1;
2529 if (i1
->dst_y
!= i2
->dst_y
) return 1;
2534 * \brief compare current and previous image list
2535 * \param priv library handle
2536 * \return 0 if identical, 1 if different positions, 2 if different content
2538 int ass_detect_change(ass_renderer_t
*priv
)
2540 ass_image_t
* img
, *img2
;
2543 img
= priv
->prev_images_root
;
2544 img2
= priv
->images_root
;
2546 while (img
&& diff
< 2) {
2547 ass_image_t
* next
, *next2
;
2550 int d
= ass_image_compare(img
, img2
);
2551 if (d
> diff
) diff
= d
;
2554 // previous list is shorter
2562 // is the previous list longer?
2570 * \brief render a frame
2571 * \param priv library handle
2572 * \param track track
2573 * \param now current video timestamp (ms)
2574 * \param detect_change a value describing how the new images differ from the previous ones will be written here:
2575 * 0 if identical, 1 if different positions, 2 if different content.
2576 * Can be NULL, in that case no detection is performed.
2578 ass_image_t
* ass_render_frame(ass_renderer_t
*priv
, ass_track_t
* track
, long long now
, int* detect_change
)
2581 event_images_t
* last
;
2585 rc
= ass_start_frame(priv
, track
, now
);
2589 // render events separately
2591 for (i
= 0; i
< track
->n_events
; ++i
) {
2592 ass_event_t
* event
= track
->events
+ i
;
2593 if ( (event
->Start
<= now
) && (now
< (event
->Start
+ event
->Duration
)) ) {
2594 if (cnt
>= priv
->eimg_size
) {
2595 priv
->eimg_size
+= 100;
2596 priv
->eimg
= realloc(priv
->eimg
, priv
->eimg_size
* sizeof(event_images_t
));
2598 rc
= ass_render_event(event
, priv
->eimg
+ cnt
);
2604 qsort(priv
->eimg
, cnt
, sizeof(event_images_t
), cmp_event_layer
);
2606 // call fix_collisions for each group of events with the same layer
2608 for (i
= 1; i
< cnt
; ++i
)
2609 if (last
->event
->Layer
!= priv
->eimg
[i
].event
->Layer
) {
2610 fix_collisions(last
, priv
->eimg
+ i
- last
);
2611 last
= priv
->eimg
+ i
;
2614 fix_collisions(last
, priv
->eimg
+ cnt
- last
);
2617 tail
= &ass_renderer
->images_root
;
2618 for (i
= 0; i
< cnt
; ++i
) {
2619 ass_image_t
* cur
= priv
->eimg
[i
].imgs
;
2628 *detect_change
= ass_detect_change(priv
);
2630 // free the previous image list
2631 ass_free_images(priv
->prev_images_root
);
2632 priv
->prev_images_root
= 0;
2634 return ass_renderer
->images_root
;