shaper: add hack to workaround grid-fitting
[libass.git] / libass / ass_render.c
1 /*
2 * Copyright (C) 2006 Evgeniy Stepanov <eugeni.stepanov@gmail.com>
3 *
4 * This file is part of libass.
5 *
6 * Permission to use, copy, modify, and distribute this software for any
7 * purpose with or without fee is hereby granted, provided that the above
8 * copyright notice and this permission notice appear in all copies.
9 *
10 * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
11 * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
12 * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
13 * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
14 * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
15 * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
16 * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
17 */
18
19 #include "config.h"
20
21 #include <assert.h>
22 #include <math.h>
23
24 #include "ass_render.h"
25 #include "ass_parse.h"
26 #include "ass_shaper.h"
27
28 #define MAX_GLYPHS_INITIAL 1024
29 #define MAX_LINES_INITIAL 64
30 #define SUBPIXEL_MASK 63
31 #define SUBPIXEL_ACCURACY 7
32
33 ASS_Renderer *ass_renderer_init(ASS_Library *library)
34 {
35 int error;
36 FT_Library ft;
37 ASS_Renderer *priv = 0;
38 int vmajor, vminor, vpatch;
39
40 error = FT_Init_FreeType(&ft);
41 if (error) {
42 ass_msg(library, MSGL_FATAL, "%s failed", "FT_Init_FreeType");
43 goto ass_init_exit;
44 }
45
46 FT_Library_Version(ft, &vmajor, &vminor, &vpatch);
47 ass_msg(library, MSGL_V, "Raster: FreeType %d.%d.%d",
48 vmajor, vminor, vpatch);
49
50 priv = calloc(1, sizeof(ASS_Renderer));
51 if (!priv) {
52 FT_Done_FreeType(ft);
53 goto ass_init_exit;
54 }
55
56 priv->synth_priv = ass_synth_init(BLUR_MAX_RADIUS);
57
58 priv->library = library;
59 priv->ftlibrary = ft;
60 // images_root and related stuff is zero-filled in calloc
61
62 priv->cache.font_cache = ass_font_cache_create();
63 priv->cache.bitmap_cache = ass_bitmap_cache_create();
64 priv->cache.composite_cache = ass_composite_cache_create();
65 priv->cache.outline_cache = ass_outline_cache_create();
66 priv->cache.glyph_max = GLYPH_CACHE_MAX;
67 priv->cache.bitmap_max_size = BITMAP_CACHE_MAX_SIZE;
68
69 priv->text_info.max_glyphs = MAX_GLYPHS_INITIAL;
70 priv->text_info.max_lines = MAX_LINES_INITIAL;
71 priv->text_info.glyphs = calloc(MAX_GLYPHS_INITIAL, sizeof(GlyphInfo));
72 priv->text_info.lines = calloc(MAX_LINES_INITIAL, sizeof(LineInfo));
73
74 priv->settings.font_size_coeff = 1.;
75
76 priv->shaper = ass_shaper_new(0);
77 ass_shaper_info(library);
78 #ifdef CONFIG_HARFBUZZ
79 priv->settings.shaper = ASS_SHAPING_COMPLEX;
80 #else
81 priv->settings.shaper = ASS_SHAPING_SIMPLE;
82 #endif
83
84 ass_init_exit:
85 if (priv)
86 ass_msg(library, MSGL_V, "Initialized");
87 else
88 ass_msg(library, MSGL_ERR, "Initialization failed");
89
90 return priv;
91 }
92
93 static void free_list_clear(ASS_Renderer *render_priv)
94 {
95 if (render_priv->free_head) {
96 FreeList *item = render_priv->free_head;
97 while(item) {
98 FreeList *oi = item;
99 free(item->object);
100 item = item->next;
101 free(oi);
102 }
103 render_priv->free_head = NULL;
104 }
105 }
106
107 void ass_renderer_done(ASS_Renderer *render_priv)
108 {
109 ass_cache_done(render_priv->cache.font_cache);
110 ass_cache_done(render_priv->cache.bitmap_cache);
111 ass_cache_done(render_priv->cache.composite_cache);
112 ass_cache_done(render_priv->cache.outline_cache);
113
114 ass_free_images(render_priv->images_root);
115 ass_free_images(render_priv->prev_images_root);
116
117 if (render_priv->state.stroker) {
118 FT_Stroker_Done(render_priv->state.stroker);
119 render_priv->state.stroker = 0;
120 }
121 if (render_priv->ftlibrary)
122 FT_Done_FreeType(render_priv->ftlibrary);
123 if (render_priv->fontconfig_priv)
124 fontconfig_done(render_priv->fontconfig_priv);
125 if (render_priv->synth_priv)
126 ass_synth_done(render_priv->synth_priv);
127 ass_shaper_free(render_priv->shaper);
128 free(render_priv->eimg);
129 free(render_priv->text_info.glyphs);
130 free(render_priv->text_info.lines);
131
132 free(render_priv->settings.default_font);
133 free(render_priv->settings.default_family);
134
135 free_list_clear(render_priv);
136 free(render_priv);
137 }
138
139 /**
140 * \brief Create a new ASS_Image
141 * Parameters are the same as ASS_Image fields.
142 */
143 static ASS_Image *my_draw_bitmap(unsigned char *bitmap, int bitmap_w,
144 int bitmap_h, int stride, int dst_x,
145 int dst_y, uint32_t color)
146 {
147 ASS_Image *img = malloc(sizeof(ASS_Image));
148
149 if (img) {
150 img->w = bitmap_w;
151 img->h = bitmap_h;
152 img->stride = stride;
153 img->bitmap = bitmap;
154 img->color = color;
155 img->dst_x = dst_x;
156 img->dst_y = dst_y;
157 }
158
159 return img;
160 }
161
162 /**
163 * \brief Mapping between script and screen coordinates
164 */
165 static double x2scr(ASS_Renderer *render_priv, double x)
166 {
167 return x * render_priv->orig_width_nocrop / render_priv->font_scale_x /
168 render_priv->track->PlayResX +
169 FFMAX(render_priv->settings.left_margin, 0);
170 }
171 static double x2scr_pos(ASS_Renderer *render_priv, double x)
172 {
173 return x * render_priv->orig_width / render_priv->font_scale_x / render_priv->track->PlayResX +
174 render_priv->settings.left_margin;
175 }
176 static double x2scr_scaled(ASS_Renderer *render_priv, double x)
177 {
178 return x * render_priv->orig_width_nocrop /
179 render_priv->track->PlayResX +
180 FFMAX(render_priv->settings.left_margin, 0);
181 }
182 static double x2scr_pos_scaled(ASS_Renderer *render_priv, double x)
183 {
184 return x * render_priv->orig_width / render_priv->track->PlayResX +
185 render_priv->settings.left_margin;
186 }
187 /**
188 * \brief Mapping between script and screen coordinates
189 */
190 static double y2scr(ASS_Renderer *render_priv, double y)
191 {
192 return y * render_priv->orig_height_nocrop /
193 render_priv->track->PlayResY +
194 FFMAX(render_priv->settings.top_margin, 0);
195 }
196 static double y2scr_pos(ASS_Renderer *render_priv, double y)
197 {
198 return y * render_priv->orig_height / render_priv->track->PlayResY +
199 render_priv->settings.top_margin;
200 }
201
202 // the same for toptitles
203 static double y2scr_top(ASS_Renderer *render_priv, double y)
204 {
205 if (render_priv->settings.use_margins)
206 return y * render_priv->orig_height_nocrop /
207 render_priv->track->PlayResY;
208 else
209 return y * render_priv->orig_height_nocrop /
210 render_priv->track->PlayResY +
211 FFMAX(render_priv->settings.top_margin, 0);
212 }
213 // the same for subtitles
214 static double y2scr_sub(ASS_Renderer *render_priv, double y)
215 {
216 if (render_priv->settings.use_margins)
217 return y * render_priv->orig_height_nocrop /
218 render_priv->track->PlayResY +
219 FFMAX(render_priv->settings.top_margin, 0)
220 + FFMAX(render_priv->settings.bottom_margin, 0);
221 else
222 return y * render_priv->orig_height_nocrop /
223 render_priv->track->PlayResY +
224 FFMAX(render_priv->settings.top_margin, 0);
225 }
226
227 /*
228 * \brief Convert bitmap glyphs into ASS_Image list with inverse clipping
229 *
230 * Inverse clipping with the following strategy:
231 * - find rectangle from (x0, y0) to (cx0, y1)
232 * - find rectangle from (cx0, y0) to (cx1, cy0)
233 * - find rectangle from (cx0, cy1) to (cx1, y1)
234 * - find rectangle from (cx1, y0) to (x1, y1)
235 * These rectangles can be invalid and in this case are discarded.
236 * Afterwards, they are clipped against the screen coordinates.
237 * In an additional pass, the rectangles need to be split up left/right for
238 * karaoke effects. This can result in a lot of bitmaps (6 to be exact).
239 */
240 static ASS_Image **render_glyph_i(ASS_Renderer *render_priv,
241 Bitmap *bm, int dst_x, int dst_y,
242 uint32_t color, uint32_t color2, int brk,
243 ASS_Image **tail)
244 {
245 int i, j, x0, y0, x1, y1, cx0, cy0, cx1, cy1, sx, sy, zx, zy;
246 Rect r[4];
247 ASS_Image *img;
248
249 dst_x += bm->left;
250 dst_y += bm->top;
251
252 // we still need to clip against screen boundaries
253 zx = x2scr_pos_scaled(render_priv, 0);
254 zy = y2scr_pos(render_priv, 0);
255 sx = x2scr_pos_scaled(render_priv, render_priv->track->PlayResX);
256 sy = y2scr_pos(render_priv, render_priv->track->PlayResY);
257
258 x0 = 0;
259 y0 = 0;
260 x1 = bm->w;
261 y1 = bm->h;
262 cx0 = render_priv->state.clip_x0 - dst_x;
263 cy0 = render_priv->state.clip_y0 - dst_y;
264 cx1 = render_priv->state.clip_x1 - dst_x;
265 cy1 = render_priv->state.clip_y1 - dst_y;
266
267 // calculate rectangles and discard invalid ones while we're at it.
268 i = 0;
269 r[i].x0 = x0;
270 r[i].y0 = y0;
271 r[i].x1 = (cx0 > x1) ? x1 : cx0;
272 r[i].y1 = y1;
273 if (r[i].x1 > r[i].x0 && r[i].y1 > r[i].y0) i++;
274 r[i].x0 = (cx0 < 0) ? x0 : cx0;
275 r[i].y0 = y0;
276 r[i].x1 = (cx1 > x1) ? x1 : cx1;
277 r[i].y1 = (cy0 > y1) ? y1 : cy0;
278 if (r[i].x1 > r[i].x0 && r[i].y1 > r[i].y0) i++;
279 r[i].x0 = (cx0 < 0) ? x0 : cx0;
280 r[i].y0 = (cy1 < 0) ? y0 : cy1;
281 r[i].x1 = (cx1 > x1) ? x1 : cx1;
282 r[i].y1 = y1;
283 if (r[i].x1 > r[i].x0 && r[i].y1 > r[i].y0) i++;
284 r[i].x0 = (cx1 < 0) ? x0 : cx1;
285 r[i].y0 = y0;
286 r[i].x1 = x1;
287 r[i].y1 = y1;
288 if (r[i].x1 > r[i].x0 && r[i].y1 > r[i].y0) i++;
289
290 // clip each rectangle to screen coordinates
291 for (j = 0; j < i; j++) {
292 r[j].x0 = (r[j].x0 + dst_x < zx) ? zx - dst_x : r[j].x0;
293 r[j].y0 = (r[j].y0 + dst_y < zy) ? zy - dst_y : r[j].y0;
294 r[j].x1 = (r[j].x1 + dst_x > sx) ? sx - dst_x : r[j].x1;
295 r[j].y1 = (r[j].y1 + dst_y > sy) ? sy - dst_y : r[j].y1;
296 }
297
298 // draw the rectangles
299 for (j = 0; j < i; j++) {
300 int lbrk = brk;
301 // kick out rectangles that are invalid now
302 if (r[j].x1 <= r[j].x0 || r[j].y1 <= r[j].y0)
303 continue;
304 // split up into left and right for karaoke, if needed
305 if (lbrk > r[j].x0) {
306 if (lbrk > r[j].x1) lbrk = r[j].x1;
307 img = my_draw_bitmap(bm->buffer + r[j].y0 * bm->stride + r[j].x0,
308 lbrk - r[j].x0, r[j].y1 - r[j].y0,
309 bm->stride, dst_x + r[j].x0, dst_y + r[j].y0, color);
310 if (!img) break;
311 *tail = img;
312 tail = &img->next;
313 }
314 if (lbrk < r[j].x1) {
315 if (lbrk < r[j].x0) lbrk = r[j].x0;
316 img = my_draw_bitmap(bm->buffer + r[j].y0 * bm->stride + lbrk,
317 r[j].x1 - lbrk, r[j].y1 - r[j].y0,
318 bm->stride, dst_x + lbrk, dst_y + r[j].y0, color2);
319 if (!img) break;
320 *tail = img;
321 tail = &img->next;
322 }
323 }
324
325 return tail;
326 }
327
328 /**
329 * \brief convert bitmap glyph into ASS_Image struct(s)
330 * \param bit freetype bitmap glyph, FT_PIXEL_MODE_GRAY
331 * \param dst_x bitmap x coordinate in video frame
332 * \param dst_y bitmap y coordinate in video frame
333 * \param color first color, RGBA
334 * \param color2 second color, RGBA
335 * \param brk x coordinate relative to glyph origin, color is used to the left of brk, color2 - to the right
336 * \param tail pointer to the last image's next field, head of the generated list should be stored here
337 * \return pointer to the new list tail
338 * Performs clipping. Uses my_draw_bitmap for actual bitmap convertion.
339 */
340 static ASS_Image **
341 render_glyph(ASS_Renderer *render_priv, Bitmap *bm, int dst_x, int dst_y,
342 uint32_t color, uint32_t color2, int brk, ASS_Image **tail)
343 {
344 // Inverse clipping in use?
345 if (render_priv->state.clip_mode)
346 return render_glyph_i(render_priv, bm, dst_x, dst_y, color, color2,
347 brk, tail);
348
349 // brk is relative to dst_x
350 // color = color left of brk
351 // color2 = color right of brk
352 int b_x0, b_y0, b_x1, b_y1; // visible part of the bitmap
353 int clip_x0, clip_y0, clip_x1, clip_y1;
354 int tmp;
355 ASS_Image *img;
356
357 dst_x += bm->left;
358 dst_y += bm->top;
359 brk -= bm->left;
360
361 // clipping
362 clip_x0 = FFMINMAX(render_priv->state.clip_x0, 0, render_priv->width);
363 clip_y0 = FFMINMAX(render_priv->state.clip_y0, 0, render_priv->height);
364 clip_x1 = FFMINMAX(render_priv->state.clip_x1, 0, render_priv->width);
365 clip_y1 = FFMINMAX(render_priv->state.clip_y1, 0, render_priv->height);
366 b_x0 = 0;
367 b_y0 = 0;
368 b_x1 = bm->w;
369 b_y1 = bm->h;
370
371 tmp = dst_x - clip_x0;
372 if (tmp < 0) {
373 ass_msg(render_priv->library, MSGL_DBG2, "clip left");
374 b_x0 = -tmp;
375 }
376 tmp = dst_y - clip_y0;
377 if (tmp < 0) {
378 ass_msg(render_priv->library, MSGL_DBG2, "clip top");
379 b_y0 = -tmp;
380 }
381 tmp = clip_x1 - dst_x - bm->w;
382 if (tmp < 0) {
383 ass_msg(render_priv->library, MSGL_DBG2, "clip right");
384 b_x1 = bm->w + tmp;
385 }
386 tmp = clip_y1 - dst_y - bm->h;
387 if (tmp < 0) {
388 ass_msg(render_priv->library, MSGL_DBG2, "clip bottom");
389 b_y1 = bm->h + tmp;
390 }
391
392 if ((b_y0 >= b_y1) || (b_x0 >= b_x1))
393 return tail;
394
395 if (brk > b_x0) { // draw left part
396 if (brk > b_x1)
397 brk = b_x1;
398 img = my_draw_bitmap(bm->buffer + bm->stride * b_y0 + b_x0,
399 brk - b_x0, b_y1 - b_y0, bm->stride,
400 dst_x + b_x0, dst_y + b_y0, color);
401 if (!img) return tail;
402 *tail = img;
403 tail = &img->next;
404 }
405 if (brk < b_x1) { // draw right part
406 if (brk < b_x0)
407 brk = b_x0;
408 img = my_draw_bitmap(bm->buffer + bm->stride * b_y0 + brk,
409 b_x1 - brk, b_y1 - b_y0, bm->stride,
410 dst_x + brk, dst_y + b_y0, color2);
411 if (!img) return tail;
412 *tail = img;
413 tail = &img->next;
414 }
415 return tail;
416 }
417
418 /**
419 * \brief Replace the bitmap buffer in ASS_Image with a copy
420 * \param img ASS_Image to operate on
421 * \return pointer to old bitmap buffer
422 */
423 static unsigned char *clone_bitmap_buffer(ASS_Image *img)
424 {
425 unsigned char *old_bitmap = img->bitmap;
426 int size = img->stride * (img->h - 1) + img->w;
427 img->bitmap = malloc(size);
428 memcpy(img->bitmap, old_bitmap, size);
429 return old_bitmap;
430 }
431
432 /**
433 * \brief Calculate overlapping area of two consecutive bitmaps and in case they
434 * overlap, blend them together
435 * Mainly useful for translucent glyphs and especially borders, to avoid the
436 * luminance adding up where they overlap (which looks ugly)
437 */
438 static void
439 render_overlap(ASS_Renderer *render_priv, ASS_Image **last_tail,
440 ASS_Image **tail)
441 {
442 int left, top, bottom, right;
443 int old_left, old_top, w, h, cur_left, cur_top;
444 int x, y, opos, cpos;
445 char m;
446 CompositeHashKey hk;
447 CompositeHashValue *hv;
448 CompositeHashValue chv;
449 int ax = (*last_tail)->dst_x;
450 int ay = (*last_tail)->dst_y;
451 int aw = (*last_tail)->w;
452 int as = (*last_tail)->stride;
453 int ah = (*last_tail)->h;
454 int bx = (*tail)->dst_x;
455 int by = (*tail)->dst_y;
456 int bw = (*tail)->w;
457 int bs = (*tail)->stride;
458 int bh = (*tail)->h;
459 unsigned char *a;
460 unsigned char *b;
461
462 if ((*last_tail)->bitmap == (*tail)->bitmap)
463 return;
464
465 if ((*last_tail)->color != (*tail)->color)
466 return;
467
468 // Calculate overlap coordinates
469 left = (ax > bx) ? ax : bx;
470 top = (ay > by) ? ay : by;
471 right = ((ax + aw) < (bx + bw)) ? (ax + aw) : (bx + bw);
472 bottom = ((ay + ah) < (by + bh)) ? (ay + ah) : (by + bh);
473 if ((right <= left) || (bottom <= top))
474 return;
475 old_left = left - ax;
476 old_top = top - ay;
477 w = right - left;
478 h = bottom - top;
479 cur_left = left - bx;
480 cur_top = top - by;
481
482 // Query cache
483 hk.a = (*last_tail)->bitmap;
484 hk.b = (*tail)->bitmap;
485 hk.aw = aw;
486 hk.ah = ah;
487 hk.bw = bw;
488 hk.bh = bh;
489 hk.ax = ax;
490 hk.ay = ay;
491 hk.bx = bx;
492 hk.by = by;
493 hk.as = as;
494 hk.bs = bs;
495 hv = ass_cache_get(render_priv->cache.composite_cache, &hk);
496 if (hv) {
497 (*last_tail)->bitmap = hv->a;
498 (*tail)->bitmap = hv->b;
499 return;
500 }
501 // Allocate new bitmaps and copy over data
502 a = clone_bitmap_buffer(*last_tail);
503 b = clone_bitmap_buffer(*tail);
504
505 // Blend overlapping area
506 for (y = 0; y < h; y++)
507 for (x = 0; x < w; x++) {
508 opos = (old_top + y) * (as) + (old_left + x);
509 cpos = (cur_top + y) * (bs) + (cur_left + x);
510 m = FFMIN(a[opos] + b[cpos], 0xff);
511 (*last_tail)->bitmap[opos] = 0;
512 (*tail)->bitmap[cpos] = m;
513 }
514
515 // Insert bitmaps into the cache
516 chv.a = (*last_tail)->bitmap;
517 chv.b = (*tail)->bitmap;
518 ass_cache_put(render_priv->cache.composite_cache, &hk, &chv);
519 }
520
521 static void free_list_add(ASS_Renderer *render_priv, void *object)
522 {
523 if (!render_priv->free_head) {
524 render_priv->free_head = calloc(1, sizeof(FreeList));
525 render_priv->free_head->object = object;
526 render_priv->free_tail = render_priv->free_head;
527 } else {
528 FreeList *l = calloc(1, sizeof(FreeList));
529 l->object = object;
530 render_priv->free_tail->next = l;
531 render_priv->free_tail = render_priv->free_tail->next;
532 }
533 }
534
535 /**
536 * Iterate through a list of bitmaps and blend with clip vector, if
537 * applicable. The blended bitmaps are added to a free list which is freed
538 * at the start of a new frame.
539 */
540 static void blend_vector_clip(ASS_Renderer *render_priv,
541 ASS_Image *head)
542 {
543 FT_Outline *outline;
544 Bitmap *clip_bm = NULL;
545 ASS_Image *cur;
546 ASS_Drawing *drawing = render_priv->state.clip_drawing;
547 BitmapHashKey key;
548 BitmapHashValue *val;
549 int error;
550
551 if (!drawing)
552 return;
553
554 // Try to get mask from cache
555 memset(&key, 0, sizeof(key));
556 key.type = BITMAP_CLIP;
557 key.u.clip.text = drawing->text;
558 val = ass_cache_get(render_priv->cache.bitmap_cache, &key);
559
560 if (val) {
561 clip_bm = val->bm;
562 } else {
563 BitmapHashValue v;
564
565 // Not found in cache, parse and rasterize it
566 outline = ass_drawing_parse(drawing, 1);
567 if (!outline) {
568 ass_msg(render_priv->library, MSGL_WARN,
569 "Clip vector parsing failed. Skipping.");
570 goto blend_vector_error;
571 }
572
573 // We need to translate the clip according to screen borders
574 if (render_priv->settings.left_margin != 0 ||
575 render_priv->settings.top_margin != 0) {
576 FT_Vector trans = {
577 .x = int_to_d6(render_priv->settings.left_margin),
578 .y = -int_to_d6(render_priv->settings.top_margin),
579 };
580 FT_Outline_Translate(outline, trans.x, trans.y);
581 }
582
583 ass_msg(render_priv->library, MSGL_DBG2,
584 "Parsed vector clip: scales (%f, %f) string [%s]\n",
585 drawing->scale_x, drawing->scale_y, drawing->text);
586
587 clip_bm = outline_to_bitmap(render_priv->library,
588 render_priv->ftlibrary, outline, 0);
589 if (clip_bm == NULL) {
590 ass_msg(render_priv->library, MSGL_WARN,
591 "Clip vector rasterization failed: %d. Skipping.", error);
592 }
593
594 // Add to cache
595 memset(&v, 0, sizeof(v));
596 key.u.clip.text = strdup(drawing->text);
597 v.bm = clip_bm;
598 ass_cache_put(render_priv->cache.bitmap_cache, &key, &v);
599 }
600 blend_vector_error:
601
602 if (!clip_bm) goto blend_vector_exit;
603
604 // Iterate through bitmaps and blend/clip them
605 for (cur = head; cur; cur = cur->next) {
606 int left, top, right, bottom, apos, bpos, y, x, w, h;
607 int ax, ay, aw, ah, as;
608 int bx, by, bw, bh, bs;
609 int aleft, atop, bleft, btop;
610 unsigned char *abuffer, *bbuffer, *nbuffer;
611
612 abuffer = cur->bitmap;
613 bbuffer = clip_bm->buffer;
614 ax = cur->dst_x;
615 ay = cur->dst_y;
616 aw = cur->w;
617 ah = cur->h;
618 as = cur->stride;
619 bx = clip_bm->left;
620 by = clip_bm->top;
621 bw = clip_bm->w;
622 bh = clip_bm->h;
623 bs = clip_bm->stride;
624
625 // Calculate overlap coordinates
626 left = (ax > bx) ? ax : bx;
627 top = (ay > by) ? ay : by;
628 right = ((ax + aw) < (bx + bw)) ? (ax + aw) : (bx + bw);
629 bottom = ((ay + ah) < (by + bh)) ? (ay + ah) : (by + bh);
630 aleft = left - ax;
631 atop = top - ay;
632 w = right - left;
633 h = bottom - top;
634 bleft = left - bx;
635 btop = top - by;
636
637 if (render_priv->state.clip_drawing_mode) {
638 // Inverse clip
639 if (ax + aw < bx || ay + ah < by || ax > bx + bw ||
640 ay > by + bh) {
641 continue;
642 }
643
644 // Allocate new buffer and add to free list
645 nbuffer = malloc(as * ah);
646 if (!nbuffer) goto blend_vector_exit;
647 free_list_add(render_priv, nbuffer);
648
649 // Blend together
650 memcpy(nbuffer, abuffer, as * (ah - 1) + aw);
651 for (y = 0; y < h; y++)
652 for (x = 0; x < w; x++) {
653 apos = (atop + y) * as + aleft + x;
654 bpos = (btop + y) * bs + bleft + x;
655 nbuffer[apos] = FFMAX(0, abuffer[apos] - bbuffer[bpos]);
656 }
657 } else {
658 // Regular clip
659 if (ax + aw < bx || ay + ah < by || ax > bx + bw ||
660 ay > by + bh) {
661 cur->w = cur->h = 0;
662 continue;
663 }
664
665 // Allocate new buffer and add to free list
666 nbuffer = calloc(as, ah);
667 if (!nbuffer) goto blend_vector_exit;
668 free_list_add(render_priv, nbuffer);
669
670 // Blend together
671 for (y = 0; y < h; y++)
672 for (x = 0; x < w; x++) {
673 apos = (atop + y) * as + aleft + x;
674 bpos = (btop + y) * bs + bleft + x;
675 nbuffer[apos] = (abuffer[apos] * bbuffer[bpos] + 255) >> 8;
676 }
677 }
678 cur->bitmap = nbuffer;
679 }
680
681 blend_vector_exit:
682 ass_drawing_free(render_priv->state.clip_drawing);
683 render_priv->state.clip_drawing = 0;
684 }
685
686 /**
687 * \brief Convert TextInfo struct to ASS_Image list
688 * Splits glyphs in halves when needed (for \kf karaoke).
689 */
690 static ASS_Image *render_text(ASS_Renderer *render_priv, int dst_x, int dst_y)
691 {
692 int pen_x, pen_y;
693 int i;
694 Bitmap *bm;
695 ASS_Image *head;
696 ASS_Image **tail = &head;
697 ASS_Image **last_tail = 0;
698 ASS_Image **here_tail = 0;
699 TextInfo *text_info = &render_priv->text_info;
700
701 for (i = 0; i < text_info->length; ++i) {
702 GlyphInfo *info = text_info->glyphs + i;
703 if ((info->symbol == 0) || (info->symbol == '\n') || !info->bm_s
704 || (info->shadow_x == 0 && info->shadow_y == 0) || info->skip)
705 continue;
706
707 while (info) {
708 if (!info->bm_s) {
709 info = info->next;
710 continue;
711 }
712
713 pen_x =
714 dst_x + (info->pos.x >> 6) +
715 (int) (info->shadow_x * render_priv->border_scale);
716 pen_y =
717 dst_y + (info->pos.y >> 6) +
718 (int) (info->shadow_y * render_priv->border_scale);
719 bm = info->bm_s;
720
721 here_tail = tail;
722 tail =
723 render_glyph(render_priv, bm, pen_x, pen_y, info->c[3], 0,
724 1000000, tail);
725
726 if (last_tail && tail != here_tail && ((info->c[3] & 0xff) > 0))
727 render_overlap(render_priv, last_tail, here_tail);
728 last_tail = here_tail;
729
730 info = info->next;
731 }
732 }
733
734 last_tail = 0;
735 for (i = 0; i < text_info->length; ++i) {
736 GlyphInfo *info = text_info->glyphs + i;
737 if ((info->symbol == 0) || (info->symbol == '\n') || !info->bm_o
738 || info->skip)
739 continue;
740
741 while (info) {
742 if (!info->bm_o) {
743 info = info->next;
744 continue;
745 }
746
747 pen_x = dst_x + (info->pos.x >> 6);
748 pen_y = dst_y + (info->pos.y >> 6);
749 bm = info->bm_o;
750
751 if ((info->effect_type == EF_KARAOKE_KO)
752 && (info->effect_timing <= (info->bbox.xMax >> 6))) {
753 // do nothing
754 } else {
755 here_tail = tail;
756 tail =
757 render_glyph(render_priv, bm, pen_x, pen_y, info->c[2],
758 0, 1000000, tail);
759 if (last_tail && tail != here_tail && ((info->c[2] & 0xff) > 0))
760 render_overlap(render_priv, last_tail, here_tail);
761
762 last_tail = here_tail;
763 }
764 info = info->next;
765 }
766 }
767
768 for (i = 0; i < text_info->length; ++i) {
769 GlyphInfo *info = text_info->glyphs + i;
770 if ((info->symbol == 0) || (info->symbol == '\n') || !info->bm
771 || info->skip)
772 continue;
773
774 while (info) {
775 if (!info->bm) {
776 info = info->next;
777 continue;
778 }
779
780 pen_x = dst_x + (info->pos.x >> 6);
781 pen_y = dst_y + (info->pos.y >> 6);
782 bm = info->bm;
783
784 if ((info->effect_type == EF_KARAOKE)
785 || (info->effect_type == EF_KARAOKE_KO)) {
786 if (info->effect_timing > (info->bbox.xMax >> 6))
787 tail =
788 render_glyph(render_priv, bm, pen_x, pen_y,
789 info->c[0], 0, 1000000, tail);
790 else
791 tail =
792 render_glyph(render_priv, bm, pen_x, pen_y,
793 info->c[1], 0, 1000000, tail);
794 } else if (info->effect_type == EF_KARAOKE_KF) {
795 tail =
796 render_glyph(render_priv, bm, pen_x, pen_y, info->c[0],
797 info->c[1], info->effect_timing, tail);
798 } else
799 tail =
800 render_glyph(render_priv, bm, pen_x, pen_y, info->c[0],
801 0, 1000000, tail);
802 info = info->next;
803 }
804 }
805
806 *tail = 0;
807 blend_vector_clip(render_priv, head);
808
809 return head;
810 }
811
812 static void compute_string_bbox(TextInfo *text, DBBox *bbox)
813 {
814 int i;
815
816 if (text->length > 0) {
817 bbox->xMin = 32000;
818 bbox->xMax = -32000;
819 bbox->yMin = -1 * text->lines[0].asc + d6_to_double(text->glyphs[0].pos.y);
820 bbox->yMax = text->height - text->lines[0].asc +
821 d6_to_double(text->glyphs[0].pos.y);
822
823 for (i = 0; i < text->length; ++i) {
824 GlyphInfo *info = text->glyphs + i;
825 if (info->skip) continue;
826 while (info) {
827 double s = d6_to_double(info->pos.x);
828 double e = s + d6_to_double(info->advance.x);
829 bbox->xMin = FFMIN(bbox->xMin, s);
830 bbox->xMax = FFMAX(bbox->xMax, e);
831 info = info->next;
832 }
833 }
834 } else
835 bbox->xMin = bbox->xMax = bbox->yMin = bbox->yMax = 0.;
836 }
837
838 /**
839 * \brief partially reset render_context to style values
840 * Works like {\r}: resets some style overrides
841 */
842 void reset_render_context(ASS_Renderer *render_priv, ASS_Style *style)
843 {
844 if (!style)
845 style = render_priv->state.style;
846
847 render_priv->state.c[0] = style->PrimaryColour;
848 render_priv->state.c[1] = style->SecondaryColour;
849 render_priv->state.c[2] = style->OutlineColour;
850 render_priv->state.c[3] = style->BackColour;
851 render_priv->state.flags =
852 (style->Underline ? DECO_UNDERLINE : 0) |
853 (style->StrikeOut ? DECO_STRIKETHROUGH : 0);
854 render_priv->state.font_size = style->FontSize;
855
856 free(render_priv->state.family);
857 render_priv->state.family = NULL;
858 render_priv->state.family = strdup(style->FontName);
859 render_priv->state.treat_family_as_pattern =
860 style->treat_fontname_as_pattern;
861 render_priv->state.bold = style->Bold;
862 render_priv->state.italic = style->Italic;
863 update_font(render_priv);
864
865 render_priv->state.border_style = style->BorderStyle;
866 calc_border(render_priv, style->Outline, style->Outline);
867 change_border(render_priv, render_priv->state.border_x, render_priv->state.border_y);
868 render_priv->state.scale_x = style->ScaleX;
869 render_priv->state.scale_y = style->ScaleY;
870 render_priv->state.hspacing = style->Spacing;
871 render_priv->state.be = 0;
872 render_priv->state.blur = 0.0;
873 render_priv->state.shadow_x = style->Shadow;
874 render_priv->state.shadow_y = style->Shadow;
875 render_priv->state.frx = render_priv->state.fry = 0.;
876 render_priv->state.frz = M_PI * style->Angle / 180.;
877 render_priv->state.fax = render_priv->state.fay = 0.;
878 render_priv->state.wrap_style = render_priv->track->WrapStyle;
879 render_priv->state.font_encoding = style->Encoding;
880 }
881
882 /**
883 * \brief Start new event. Reset render_priv->state.
884 */
885 static void
886 init_render_context(ASS_Renderer *render_priv, ASS_Event *event)
887 {
888 render_priv->state.event = event;
889 render_priv->state.style = render_priv->track->styles + event->Style;
890 render_priv->state.parsed_tags = 0;
891
892 reset_render_context(render_priv, render_priv->state.style);
893
894 render_priv->state.evt_type = EVENT_NORMAL;
895 render_priv->state.alignment = render_priv->state.style->Alignment;
896 render_priv->state.pos_x = 0;
897 render_priv->state.pos_y = 0;
898 render_priv->state.org_x = 0;
899 render_priv->state.org_y = 0;
900 render_priv->state.have_origin = 0;
901 render_priv->state.clip_x0 = 0;
902 render_priv->state.clip_y0 = 0;
903 render_priv->state.clip_x1 = render_priv->track->PlayResX;
904 render_priv->state.clip_y1 = render_priv->track->PlayResY;
905 render_priv->state.clip_mode = 0;
906 render_priv->state.detect_collisions = 1;
907 render_priv->state.fade = 0;
908 render_priv->state.drawing_mode = 0;
909 render_priv->state.effect_type = EF_NONE;
910 render_priv->state.effect_timing = 0;
911 render_priv->state.effect_skip_timing = 0;
912 render_priv->state.bm_run_id = 0;
913 ass_drawing_free(render_priv->state.drawing);
914 render_priv->state.drawing = ass_drawing_new(render_priv->library,
915 render_priv->ftlibrary);
916
917 apply_transition_effects(render_priv, event);
918 }
919
920 static void free_render_context(ASS_Renderer *render_priv)
921 {
922 free(render_priv->state.family);
923 ass_drawing_free(render_priv->state.drawing);
924
925 render_priv->state.family = NULL;
926 render_priv->state.drawing = NULL;
927 }
928
929 /*
930 * Replace the outline of a glyph by a contour which makes up a simple
931 * opaque rectangle.
932 */
933 static void draw_opaque_box(ASS_Renderer *render_priv, int asc, int desc,
934 FT_Outline *ol, FT_Vector advance, int sx, int sy)
935 {
936 int i;
937 int adv = advance.x;
938 double scale_y = render_priv->state.scale_y;
939 double scale_x = render_priv->state.scale_x;
940
941 // to avoid gaps
942 sx = FFMAX(64, sx);
943 sy = FFMAX(64, sy);
944
945 // Emulate the WTFish behavior of VSFilter, i.e. double-scale
946 // the sizes of the opaque box.
947 adv += double_to_d6(render_priv->state.hspacing * render_priv->font_scale
948 * scale_x);
949 adv *= scale_x;
950 sx *= scale_x;
951 sy *= scale_y;
952 desc *= scale_y;
953 desc += asc * (scale_y - 1.0);
954
955 FT_Vector points[4] = {
956 { .x = -sx, .y = asc + sy },
957 { .x = adv + sx, .y = asc + sy },
958 { .x = adv + sx, .y = -desc - sy },
959 { .x = -sx, .y = -desc - sy },
960 };
961
962 FT_Outline_New(render_priv->ftlibrary, 4, 1, ol);
963
964 ol->n_points = ol->n_contours = 0;
965 for (i = 0; i < 4; i++) {
966 ol->points[ol->n_points] = points[i];
967 ol->tags[ol->n_points++] = 1;
968 }
969 ol->contours[ol->n_contours++] = ol->n_points - 1;
970 }
971
972 /*
973 * Stroke an outline glyph in x/y direction. Applies various fixups to get
974 * around limitations of the FreeType stroker.
975 */
976 static void stroke_outline(ASS_Renderer *render_priv, FT_Outline *outline,
977 int sx, int sy)
978 {
979 if (sx <= 0 && sy <= 0)
980 return;
981
982 fix_freetype_stroker(outline, sx, sy);
983
984 // Borders are equal; use the regular stroker
985 if (sx == sy && render_priv->state.stroker) {
986 int error;
987 unsigned n_points, n_contours;
988
989 FT_StrokerBorder border = FT_Outline_GetOutsideBorder(outline);
990 error = FT_Stroker_ParseOutline(render_priv->state.stroker, outline, 0);
991 if (error) {
992 ass_msg(render_priv->library, MSGL_WARN,
993 "FT_Stroker_ParseOutline failed, error: %d", error);
994 }
995 error = FT_Stroker_GetBorderCounts(render_priv->state.stroker, border,
996 &n_points, &n_contours);
997 if (error) {
998 ass_msg(render_priv->library, MSGL_WARN,
999 "FT_Stroker_GetBorderCounts failed, error: %d", error);
1000 }
1001 FT_Outline_Done(render_priv->ftlibrary, outline);
1002 FT_Outline_New(render_priv->ftlibrary, n_points, n_contours, outline);
1003 outline->n_points = outline->n_contours = 0;
1004 FT_Stroker_ExportBorder(render_priv->state.stroker, border, outline);
1005
1006 // "Stroke" with the outline emboldener in two passes.
1007 // The outlines look uglier, but the emboldening never adds any points
1008 } else {
1009 int i;
1010 FT_Outline nol;
1011
1012 FT_Outline_New(render_priv->ftlibrary, outline->n_points,
1013 outline->n_contours, &nol);
1014 FT_Outline_Copy(outline, &nol);
1015
1016 FT_Outline_Embolden(outline, sx * 2);
1017 FT_Outline_Translate(outline, -sx, -sx);
1018 FT_Outline_Embolden(&nol, sy * 2);
1019 FT_Outline_Translate(&nol, -sy, -sy);
1020
1021 for (i = 0; i < outline->n_points; i++)
1022 outline->points[i].y = nol.points[i].y;
1023
1024 FT_Outline_Done(render_priv->ftlibrary, &nol);
1025 }
1026 }
1027
1028 /**
1029 * \brief Prepare glyph hash
1030 */
1031 static void
1032 fill_glyph_hash(ASS_Renderer *priv, OutlineHashKey *outline_key,
1033 GlyphInfo *info)
1034 {
1035 if (info->drawing) {
1036 DrawingHashKey *key = &outline_key->u.drawing;
1037 outline_key->type = OUTLINE_DRAWING;
1038 key->scale_x = double_to_d16(info->scale_x);
1039 key->scale_y = double_to_d16(info->scale_y);
1040 key->outline.x = double_to_d16(info->border_x);
1041 key->outline.y = double_to_d16(info->border_y);
1042 key->border_style = info->border_style;
1043 key->hash = info->drawing->hash;
1044 key->text = info->drawing->text;
1045 key->pbo = info->drawing->pbo;
1046 key->scale = info->drawing->scale;
1047 } else {
1048 GlyphHashKey *key = &outline_key->u.glyph;
1049 outline_key->type = OUTLINE_GLYPH;
1050 key->font = info->font;
1051 key->size = info->font_size;
1052 key->face_index = info->face_index;
1053 key->glyph_index = info->glyph_index;
1054 key->bold = info->bold;
1055 key->italic = info->italic;
1056 key->scale_x = double_to_d16(info->scale_x);
1057 key->scale_y = double_to_d16(info->scale_y);
1058 key->outline.x = double_to_d16(info->border_x);
1059 key->outline.y = double_to_d16(info->border_y);
1060 key->flags = info->flags;
1061 key->border_style = info->border_style;
1062 }
1063 }
1064
1065 /**
1066 * \brief Get normal and outline (border) glyphs
1067 * \param info out: struct filled with extracted data
1068 * Tries to get both glyphs from cache.
1069 * If they can't be found, gets a glyph from font face, generates outline with FT_Stroker,
1070 * and add them to cache.
1071 * The glyphs are returned in info->glyph and info->outline_glyph
1072 */
1073 static void
1074 get_outline_glyph(ASS_Renderer *priv, GlyphInfo *info)
1075 {
1076 OutlineHashValue *val;
1077 OutlineHashKey key;
1078
1079 memset(&info->hash_key, 0, sizeof(key));
1080
1081 fill_glyph_hash(priv, &key, info);
1082 val = ass_cache_get(priv->cache.outline_cache, &key);
1083
1084 if (!val) {
1085 OutlineHashValue v;
1086 memset(&v, 0, sizeof(v));
1087
1088 if (info->drawing) {
1089 ASS_Drawing *drawing = info->drawing;
1090 ass_drawing_hash(drawing);
1091 if(!ass_drawing_parse(drawing, 0))
1092 return;
1093 outline_copy(priv->ftlibrary, &drawing->outline,
1094 &v.outline);
1095 v.advance.x = drawing->advance.x;
1096 v.advance.y = drawing->advance.y;
1097 v.asc = drawing->asc;
1098 v.desc = drawing->desc;
1099 key.u.drawing.text = strdup(drawing->text);
1100 } else {
1101 // arbitrary, not too small to prevent grid fitting rounding effects
1102 // XXX: this is a rather crude hack
1103 const double ft_size = 256.0;
1104 ass_face_set_size(info->font->faces[info->face_index], ft_size);
1105 ass_font_set_transform(info->font,
1106 info->scale_x * info->font_size / ft_size,
1107 info->scale_y * info->font_size / ft_size,
1108 NULL);
1109 FT_Glyph glyph =
1110 ass_font_get_glyph(priv->fontconfig_priv, info->font,
1111 info->symbol, info->face_index, info->glyph_index,
1112 priv->settings.hinting, info->flags);
1113 if (glyph != NULL) {
1114 outline_copy(priv->ftlibrary,
1115 &((FT_OutlineGlyph)glyph)->outline, &v.outline);
1116 if (priv->settings.shaper == ASS_SHAPING_SIMPLE) {
1117 v.advance.x = d16_to_d6(glyph->advance.x);
1118 v.advance.y = d16_to_d6(glyph->advance.y);
1119 }
1120 FT_Done_Glyph(glyph);
1121 ass_font_get_asc_desc(info->font, info->symbol,
1122 &v.asc, &v.desc);
1123 v.asc *= info->scale_y * info->font_size / ft_size;
1124 v.desc *= info->scale_y * info->font_size / ft_size;
1125 }
1126 }
1127
1128 if (!v.outline)
1129 return;
1130
1131 FT_Outline_Get_CBox(v.outline, &v.bbox_scaled);
1132
1133 if (info->border_style == 3 &&
1134 (info->border_x > 0 || info->border_y > 0)) {
1135 FT_Vector advance;
1136
1137 v.border = calloc(1, sizeof(FT_Outline));
1138
1139 if (priv->settings.shaper == ASS_SHAPING_SIMPLE || info->drawing)
1140 advance = v.advance;
1141 else
1142 advance = info->advance;
1143
1144 draw_opaque_box(priv, v.asc, v.desc, v.border, advance,
1145 double_to_d6(info->border_x * priv->border_scale),
1146 double_to_d6(info->border_y * priv->border_scale));
1147
1148 } else if ((info->border_x > 0 || info->border_y > 0)
1149 && double_to_d6(info->scale_x) && double_to_d6(info->scale_y)) {
1150
1151 change_border(priv, info->border_x, info->border_y);
1152 outline_copy(priv->ftlibrary, v.outline, &v.border);
1153 stroke_outline(priv, v.border,
1154 double_to_d6(info->border_x * priv->border_scale),
1155 double_to_d6(info->border_y * priv->border_scale));
1156 }
1157
1158 v.lib = priv->ftlibrary;
1159 val = ass_cache_put(priv->cache.outline_cache, &key, &v);
1160 }
1161
1162 info->hash_key.u.outline.outline = val;
1163 info->outline = val->outline;
1164 info->border = val->border;
1165 info->bbox = val->bbox_scaled;
1166 if (info->drawing || priv->settings.shaper == ASS_SHAPING_SIMPLE) {
1167 info->cluster_advance.x = info->advance.x = val->advance.x;
1168 info->cluster_advance.y = info->advance.y = val->advance.y;
1169 }
1170 info->asc = val->asc;
1171 info->desc = val->desc;
1172
1173 ass_drawing_free(info->drawing);
1174 }
1175
1176 /**
1177 * \brief Apply transformation to outline points of a glyph
1178 * Applies rotations given by frx, fry and frz and projects the points back
1179 * onto the screen plane.
1180 */
1181 static void
1182 transform_3d_points(FT_Vector shift, FT_Outline *outline, double frx, double fry,
1183 double frz, double fax, double fay, double scale,
1184 int yshift)
1185 {
1186 double sx = sin(frx);
1187 double sy = sin(fry);
1188 double sz = sin(frz);
1189 double cx = cos(frx);
1190 double cy = cos(fry);
1191 double cz = cos(frz);
1192 FT_Vector *p = outline->points;
1193 double x, y, z, xx, yy, zz;
1194 int i, dist;
1195
1196 dist = 20000 * scale;
1197 for (i = 0; i < outline->n_points; i++) {
1198 x = (double) p[i].x + shift.x + (fax * (yshift - p[i].y));
1199 y = (double) p[i].y + shift.y + (-fay * p[i].x);
1200 z = 0.;
1201
1202 xx = x * cz + y * sz;
1203 yy = -(x * sz - y * cz);
1204 zz = z;
1205
1206 x = xx;
1207 y = yy * cx + zz * sx;
1208 z = yy * sx - zz * cx;
1209
1210 xx = x * cy + z * sy;
1211 yy = y;
1212 zz = x * sy - z * cy;
1213
1214 zz = FFMAX(zz, 1000 - dist);
1215
1216 x = (xx * dist) / (zz + dist);
1217 y = (yy * dist) / (zz + dist);
1218 p[i].x = x - shift.x + 0.5;
1219 p[i].y = y - shift.y + 0.5;
1220 }
1221 }
1222
1223 /**
1224 * \brief Apply 3d transformation to several objects
1225 * \param shift FreeType vector
1226 * \param glyph FreeType glyph
1227 * \param glyph2 FreeType glyph
1228 * \param frx x-axis rotation angle
1229 * \param fry y-axis rotation angle
1230 * \param frz z-axis rotation angle
1231 * Rotates both glyphs by frx, fry and frz. Shift vector is added before rotation and subtracted after it.
1232 */
1233 static void
1234 transform_3d(FT_Vector shift, FT_Outline *outline, FT_Outline *border,
1235 double frx, double fry, double frz, double fax, double fay,
1236 double scale, int yshift)
1237 {
1238 frx = -frx;
1239 frz = -frz;
1240 if (frx != 0. || fry != 0. || frz != 0. || fax != 0. || fay != 0.) {
1241 if (outline)
1242 transform_3d_points(shift, outline, frx, fry, frz,
1243 fax, fay, scale, yshift);
1244
1245 if (border)
1246 transform_3d_points(shift, border, frx, fry, frz,
1247 fax, fay, scale, yshift);
1248 }
1249 }
1250
1251 /**
1252 * \brief Get bitmaps for a glyph
1253 * \param info glyph info
1254 * Tries to get glyph bitmaps from bitmap cache.
1255 * If they can't be found, they are generated by rotating and rendering the glyph.
1256 * After that, bitmaps are added to the cache.
1257 * They are returned in info->bm (glyph), info->bm_o (outline) and info->bm_s (shadow).
1258 */
1259 static void
1260 get_bitmap_glyph(ASS_Renderer *render_priv, GlyphInfo *info)
1261 {
1262 BitmapHashValue *val;
1263 OutlineBitmapHashKey *key = &info->hash_key.u.outline;
1264
1265 if (!info->outline || info->symbol == '\n' || info->symbol == 0 || info->skip)
1266 return;
1267
1268 val = ass_cache_get(render_priv->cache.bitmap_cache, &info->hash_key);
1269
1270 if (!val) {
1271 FT_Vector shift;
1272 BitmapHashValue hash_val;
1273 int error;
1274 double fax_scaled, fay_scaled;
1275 FT_Outline *outline, *border;
1276 double scale_x = render_priv->font_scale_x;
1277
1278 hash_val.bm = hash_val.bm_o = hash_val.bm_s = 0;
1279
1280 outline_copy(render_priv->ftlibrary, info->outline, &outline);
1281 outline_copy(render_priv->ftlibrary, info->border, &border);
1282
1283 // calculating rotation shift vector (from rotation origin to the glyph basepoint)
1284 shift.x = key->shift_x;
1285 shift.y = key->shift_y;
1286 fax_scaled = info->fax / info->scale_y * info->scale_x;
1287 fay_scaled = info->fay / info->scale_x * info->scale_y;
1288
1289 // apply rotation
1290 transform_3d(shift, outline, border,
1291 info->frx, info->fry, info->frz, fax_scaled,
1292 fay_scaled, render_priv->font_scale, info->asc);
1293
1294 // PAR correction scaling
1295 FT_Matrix m = { double_to_d16(scale_x), 0,
1296 0, double_to_d16(1.0) };
1297
1298 // subpixel shift
1299 if (outline) {
1300 if (scale_x != 1.0)
1301 FT_Outline_Transform(outline, &m);
1302 FT_Outline_Translate(outline, key->advance.x, -key->advance.y);
1303 }
1304 if (border) {
1305 if (scale_x != 1.0)
1306 FT_Outline_Transform(border, &m);
1307 FT_Outline_Translate(border, key->advance.x, -key->advance.y);
1308 }
1309
1310 // render glyph
1311 error = outline_to_bitmap3(render_priv->library,
1312 render_priv->synth_priv,
1313 render_priv->ftlibrary,
1314 outline, border,
1315 &hash_val.bm, &hash_val.bm_o,
1316 &hash_val.bm_s, info->be,
1317 info->blur * render_priv->border_scale,
1318 key->shadow_offset,
1319 info->border_style);
1320 if (error)
1321 info->symbol = 0;
1322
1323 val = ass_cache_put(render_priv->cache.bitmap_cache, &info->hash_key,
1324 &hash_val);
1325
1326 outline_free(render_priv->ftlibrary, outline);
1327 outline_free(render_priv->ftlibrary, border);
1328 }
1329
1330 info->bm = val->bm;
1331 info->bm_o = val->bm_o;
1332 info->bm_s = val->bm_s;
1333
1334 // VSFilter compatibility: invisible fill and no border?
1335 // In this case no shadow is supposed to be rendered.
1336 if (!info->border && (info->c[0] & 0xFF) == 0xFF)
1337 info->bm_s = 0;
1338 }
1339
1340 /**
1341 * This function goes through text_info and calculates text parameters.
1342 * The following text_info fields are filled:
1343 * height
1344 * lines[].height
1345 * lines[].asc
1346 * lines[].desc
1347 */
1348 static void measure_text(ASS_Renderer *render_priv)
1349 {
1350 TextInfo *text_info = &render_priv->text_info;
1351 int cur_line = 0;
1352 double max_asc = 0., max_desc = 0.;
1353 GlyphInfo *last = NULL;
1354 int i;
1355 int empty_line = 1;
1356 text_info->height = 0.;
1357 for (i = 0; i < text_info->length + 1; ++i) {
1358 if ((i == text_info->length) || text_info->glyphs[i].linebreak) {
1359 if (empty_line && cur_line > 0 && last && i < text_info->length) {
1360 max_asc = d6_to_double(last->asc) / 2.0;
1361 max_desc = d6_to_double(last->desc) / 2.0;
1362 }
1363 text_info->lines[cur_line].asc = max_asc;
1364 text_info->lines[cur_line].desc = max_desc;
1365 text_info->height += max_asc + max_desc;
1366 cur_line++;
1367 max_asc = max_desc = 0.;
1368 empty_line = 1;
1369 } else
1370 empty_line = 0;
1371 if (i < text_info->length) {
1372 GlyphInfo *cur = text_info->glyphs + i;
1373 if (d6_to_double(cur->asc) > max_asc)
1374 max_asc = d6_to_double(cur->asc);
1375 if (d6_to_double(cur->desc) > max_desc)
1376 max_desc = d6_to_double(cur->desc);
1377 if (cur->symbol != '\n' && cur->symbol != 0)
1378 last = cur;
1379 }
1380 }
1381 text_info->height +=
1382 (text_info->n_lines -
1383 1) * render_priv->settings.line_spacing;
1384 }
1385
1386 /**
1387 * Mark extra whitespace for later removal.
1388 */
1389 #define IS_WHITESPACE(x) ((x->symbol == ' ' || x->symbol == '\n') \
1390 && !x->linebreak)
1391 static void trim_whitespace(ASS_Renderer *render_priv)
1392 {
1393 int i, j;
1394 GlyphInfo *cur;
1395 TextInfo *ti = &render_priv->text_info;
1396
1397 // Mark trailing spaces
1398 i = ti->length - 1;
1399 cur = ti->glyphs + i;
1400 while (i && IS_WHITESPACE(cur)) {
1401 cur->skip++;
1402 cur = ti->glyphs + --i;
1403 }
1404
1405 // Mark leading whitespace
1406 i = 0;
1407 cur = ti->glyphs;
1408 while (i < ti->length && IS_WHITESPACE(cur)) {
1409 cur->skip++;
1410 cur = ti->glyphs + ++i;
1411 }
1412
1413 // Mark all extraneous whitespace inbetween
1414 for (i = 0; i < ti->length; ++i) {
1415 cur = ti->glyphs + i;
1416 if (cur->linebreak) {
1417 // Mark whitespace before
1418 j = i - 1;
1419 cur = ti->glyphs + j;
1420 while (j && IS_WHITESPACE(cur)) {
1421 cur->skip++;
1422 cur = ti->glyphs + --j;
1423 }
1424 // A break itself can contain a whitespace, too
1425 cur = ti->glyphs + i;
1426 if (cur->symbol == ' ') {
1427 cur->skip++;
1428 // Mark whitespace after
1429 j = i + 1;
1430 cur = ti->glyphs + j;
1431 while (j < ti->length && IS_WHITESPACE(cur)) {
1432 cur->skip++;
1433 cur = ti->glyphs + ++j;
1434 }
1435 i = j - 1;
1436 }
1437 }
1438 }
1439 }
1440 #undef IS_WHITESPACE
1441
1442 /**
1443 * \brief rearrange text between lines
1444 * \param max_text_width maximal text line width in pixels
1445 * The algo is similar to the one in libvo/sub.c:
1446 * 1. Place text, wrapping it when current line is full
1447 * 2. Try moving words from the end of a line to the beginning of the next one while it reduces
1448 * the difference in lengths between this two lines.
1449 * The result may not be optimal, but usually is good enough.
1450 *
1451 * FIXME: implement style 0 and 3 correctly
1452 */
1453 static void
1454 wrap_lines_smart(ASS_Renderer *render_priv, double max_text_width)
1455 {
1456 int i;
1457 GlyphInfo *cur, *s1, *e1, *s2, *s3, *w;
1458 int last_space;
1459 int break_type;
1460 int exit;
1461 double pen_shift_x;
1462 double pen_shift_y;
1463 int cur_line;
1464 int run_offset;
1465 TextInfo *text_info = &render_priv->text_info;
1466
1467 last_space = -1;
1468 text_info->n_lines = 1;
1469 break_type = 0;
1470 s1 = text_info->glyphs; // current line start
1471 for (i = 0; i < text_info->length; ++i) {
1472 int break_at = -1;
1473 double s_offset, len;
1474 cur = text_info->glyphs + i;
1475 s_offset = d6_to_double(s1->bbox.xMin + s1->pos.x);
1476 len = d6_to_double(cur->bbox.xMax + cur->pos.x) - s_offset;
1477
1478 if (cur->symbol == '\n') {
1479 break_type = 2;
1480 break_at = i;
1481 ass_msg(render_priv->library, MSGL_DBG2,
1482 "forced line break at %d", break_at);
1483 } else if (cur->symbol == ' ') {
1484 last_space = i;
1485 } else if (len >= max_text_width
1486 && (render_priv->state.wrap_style != 2)) {
1487 break_type = 1;
1488 break_at = last_space;
1489 if (break_at >= 0)
1490 ass_msg(render_priv->library, MSGL_DBG2, "line break at %d",
1491 break_at);
1492 }
1493
1494 if (break_at != -1) {
1495 // need to use one more line
1496 // marking break_at+1 as start of a new line
1497 int lead = break_at + 1; // the first symbol of the new line
1498 if (text_info->n_lines >= text_info->max_lines) {
1499 // Raise maximum number of lines
1500 text_info->max_lines *= 2;
1501 text_info->lines = realloc(text_info->lines,
1502 sizeof(LineInfo) *
1503 text_info->max_lines);
1504 }
1505 if (lead < text_info->length) {
1506 text_info->glyphs[lead].linebreak = break_type;
1507 last_space = -1;
1508 s1 = text_info->glyphs + lead;
1509 s_offset = d6_to_double(s1->bbox.xMin + s1->pos.x);
1510 text_info->n_lines++;
1511 }
1512 }
1513 }
1514 #define DIFF(x,y) (((x) < (y)) ? (y - x) : (x - y))
1515 exit = 0;
1516 while (!exit && render_priv->state.wrap_style != 1) {
1517 exit = 1;
1518 w = s3 = text_info->glyphs;
1519 s1 = s2 = 0;
1520 for (i = 0; i <= text_info->length; ++i) {
1521 cur = text_info->glyphs + i;
1522 if ((i == text_info->length) || cur->linebreak) {
1523 s1 = s2;
1524 s2 = s3;
1525 s3 = cur;
1526 if (s1 && (s2->linebreak == 1)) { // have at least 2 lines, and linebreak is 'soft'
1527 double l1, l2, l1_new, l2_new;
1528
1529 w = s2;
1530 do {
1531 --w;
1532 } while ((w > s1) && (w->symbol == ' '));
1533 while ((w > s1) && (w->symbol != ' ')) {
1534 --w;
1535 }
1536 e1 = w;
1537 while ((e1 > s1) && (e1->symbol == ' ')) {
1538 --e1;
1539 }
1540 if (w->symbol == ' ')
1541 ++w;
1542
1543 l1 = d6_to_double(((s2 - 1)->bbox.xMax + (s2 - 1)->pos.x) -
1544 (s1->bbox.xMin + s1->pos.x));
1545 l2 = d6_to_double(((s3 - 1)->bbox.xMax + (s3 - 1)->pos.x) -
1546 (s2->bbox.xMin + s2->pos.x));
1547 l1_new = d6_to_double(
1548 (e1->bbox.xMax + e1->pos.x) -
1549 (s1->bbox.xMin + s1->pos.x));
1550 l2_new = d6_to_double(
1551 ((s3 - 1)->bbox.xMax + (s3 - 1)->pos.x) -
1552 (w->bbox.xMin + w->pos.x));
1553
1554 if (DIFF(l1_new, l2_new) < DIFF(l1, l2)) {
1555 w->linebreak = 1;
1556 s2->linebreak = 0;
1557 exit = 0;
1558 }
1559 }
1560 }
1561 if (i == text_info->length)
1562 break;
1563 }
1564
1565 }
1566 assert(text_info->n_lines >= 1);
1567 #undef DIFF
1568
1569 measure_text(render_priv);
1570 trim_whitespace(render_priv);
1571
1572 pen_shift_x = 0.;
1573 pen_shift_y = 0.;
1574 cur_line = 1;
1575 run_offset = 0;
1576
1577 i = 0;
1578 cur = text_info->glyphs + i;
1579 while (i < text_info->length && cur->skip)
1580 cur = text_info->glyphs + ++i;
1581 pen_shift_x = d6_to_double(-cur->pos.x);
1582
1583 for (i = 0; i < text_info->length; ++i) {
1584 cur = text_info->glyphs + i;
1585 if (cur->linebreak) {
1586 while (i < text_info->length && cur->skip && cur->symbol != '\n')
1587 cur = text_info->glyphs + ++i;
1588 double height =
1589 text_info->lines[cur_line - 1].desc +
1590 text_info->lines[cur_line].asc;
1591 text_info->lines[cur_line - 1].len = i -
1592 text_info->lines[cur_line - 1].offset;
1593 text_info->lines[cur_line].offset = i;
1594 cur_line++;
1595 run_offset++;
1596 pen_shift_x = d6_to_double(-cur->pos.x);
1597 pen_shift_y += height + render_priv->settings.line_spacing;
1598 ass_msg(render_priv->library, MSGL_DBG2,
1599 "shifting from %d to %d by (%f, %f)", i,
1600 text_info->length - 1, pen_shift_x, pen_shift_y);
1601 }
1602 cur->bm_run_id += run_offset;
1603 cur->pos.x += double_to_d6(pen_shift_x);
1604 cur->pos.y += double_to_d6(pen_shift_y);
1605 }
1606 text_info->lines[cur_line - 1].len =
1607 text_info->length - text_info->lines[cur_line - 1].offset;
1608
1609 #if 0
1610 // print line info
1611 for (i = 0; i < text_info->n_lines; i++) {
1612 printf("line %d offset %d length %d\n", i, text_info->lines[i].offset,
1613 text_info->lines[i].len);
1614 }
1615 #endif
1616 }
1617
1618 /**
1619 * \brief Calculate base point for positioning and rotation
1620 * \param bbox text bbox
1621 * \param alignment alignment
1622 * \param bx, by out: base point coordinates
1623 */
1624 static void get_base_point(DBBox *bbox, int alignment, double *bx, double *by)
1625 {
1626 const int halign = alignment & 3;
1627 const int valign = alignment & 12;
1628 if (bx)
1629 switch (halign) {
1630 case HALIGN_LEFT:
1631 *bx = bbox->xMin;
1632 break;
1633 case HALIGN_CENTER:
1634 *bx = (bbox->xMax + bbox->xMin) / 2.0;
1635 break;
1636 case HALIGN_RIGHT:
1637 *bx = bbox->xMax;
1638 break;
1639 }
1640 if (by)
1641 switch (valign) {
1642 case VALIGN_TOP:
1643 *by = bbox->yMin;
1644 break;
1645 case VALIGN_CENTER:
1646 *by = (bbox->yMax + bbox->yMin) / 2.0;
1647 break;
1648 case VALIGN_SUB:
1649 *by = bbox->yMax;
1650 break;
1651 }
1652 }
1653
1654 /**
1655 * Prepare bitmap hash key of a glyph
1656 */
1657 static void
1658 fill_bitmap_hash(ASS_Renderer *priv, GlyphInfo *info,
1659 OutlineBitmapHashKey *hash_key)
1660 {
1661 hash_key->frx = rot_key(info->frx);
1662 hash_key->fry = rot_key(info->fry);
1663 hash_key->frz = rot_key(info->frz);
1664 hash_key->fax = double_to_d16(info->fax);
1665 hash_key->fay = double_to_d16(info->fay);
1666 hash_key->be = info->be;
1667 hash_key->blur = info->blur;
1668 hash_key->shadow_offset.x = double_to_d6(
1669 info->shadow_x * priv->border_scale -
1670 (int) (info->shadow_x * priv->border_scale));
1671 hash_key->shadow_offset.y = double_to_d6(
1672 info->shadow_y * priv->border_scale -
1673 (int) (info->shadow_y * priv->border_scale));
1674 }
1675
1676 /**
1677 * \brief Main ass rendering function, glues everything together
1678 * \param event event to render
1679 * \param event_images struct containing resulting images, will also be initialized
1680 * Process event, appending resulting ASS_Image's to images_root.
1681 */
1682 static int
1683 ass_render_event(ASS_Renderer *render_priv, ASS_Event *event,
1684 EventImages *event_images)
1685 {
1686 char *p;
1687 FT_UInt previous;
1688 FT_UInt num_glyphs;
1689 FT_Vector pen;
1690 unsigned code;
1691 DBBox bbox;
1692 int i, j;
1693 int MarginL, MarginR, MarginV;
1694 int last_break;
1695 int alignment, halign, valign;
1696 double device_x = 0;
1697 double device_y = 0;
1698 TextInfo *text_info = &render_priv->text_info;
1699 GlyphInfo *glyphs = render_priv->text_info.glyphs;
1700 ASS_Drawing *drawing;
1701
1702 if (event->Style >= render_priv->track->n_styles) {
1703 ass_msg(render_priv->library, MSGL_WARN, "No style found");
1704 return 1;
1705 }
1706 if (!event->Text) {
1707 ass_msg(render_priv->library, MSGL_WARN, "Empty event");
1708 return 1;
1709 }
1710
1711 init_render_context(render_priv, event);
1712
1713 drawing = render_priv->state.drawing;
1714 text_info->length = 0;
1715 num_glyphs = 0;
1716 p = event->Text;
1717
1718 int in_tag = 0;
1719
1720 // Event parsing.
1721 while (1) {
1722 // get next char, executing style override
1723 // this affects render_context
1724 do {
1725 code = 0;
1726 if (!in_tag && *p == '{') { // '\0' goes here
1727 p++;
1728 in_tag = 1;
1729 }
1730 if (in_tag) {
1731 int prev_drawing_mode = render_priv->state.drawing_mode;
1732 p = parse_tag(render_priv, p, 1.);
1733 if (*p == '}') { // end of tag
1734 p++;
1735 in_tag = 0;
1736 } else if (*p != '\\') {
1737 ass_msg(render_priv->library, MSGL_V,
1738 "Unable to parse: '%.30s'", p);
1739 }
1740 if (prev_drawing_mode && !render_priv->state.drawing_mode) {
1741 // Drawing mode was just disabled. We must exit and draw it
1742 // immediately, instead of letting further tags affect it.
1743 // See bug #47.
1744 break;
1745 }
1746 } else {
1747 code = get_next_char(render_priv, &p);
1748 if (code && render_priv->state.drawing_mode) {
1749 ass_drawing_add_char(drawing, (char) code);
1750 continue; // skip everything in drawing mode
1751 }
1752 break;
1753 }
1754 } while (*p);
1755
1756 if (text_info->length >= text_info->max_glyphs) {
1757 // Raise maximum number of glyphs
1758 text_info->max_glyphs *= 2;
1759 text_info->glyphs = glyphs =
1760 realloc(text_info->glyphs,
1761 sizeof(GlyphInfo) * text_info->max_glyphs);
1762 }
1763
1764 // Clear current GlyphInfo
1765 memset(&glyphs[text_info->length], 0, sizeof(GlyphInfo));
1766
1767 // Parse drawing
1768 if (drawing->i) {
1769 drawing->scale_x = render_priv->state.scale_x *
1770 render_priv->font_scale;
1771 drawing->scale_y = render_priv->state.scale_y *
1772 render_priv->font_scale;
1773 code = 0xfffc; // object replacement character
1774 glyphs[text_info->length].drawing = drawing;
1775 }
1776
1777 // face could have been changed in get_next_char
1778 if (!render_priv->state.font) {
1779 free_render_context(render_priv);
1780 return 1;
1781 }
1782
1783 if (code == 0)
1784 break;
1785
1786 // Fill glyph information
1787 glyphs[text_info->length].symbol = code;
1788 glyphs[text_info->length].font = render_priv->state.font;
1789 for (i = 0; i < 4; ++i) {
1790 uint32_t clr = render_priv->state.c[i];
1791 change_alpha(&clr,
1792 mult_alpha(_a(clr), render_priv->state.fade), 1.);
1793 glyphs[text_info->length].c[i] = clr;
1794 }
1795 glyphs[text_info->length].effect_type = render_priv->state.effect_type;
1796 glyphs[text_info->length].effect_timing =
1797 render_priv->state.effect_timing;
1798 glyphs[text_info->length].effect_skip_timing =
1799 render_priv->state.effect_skip_timing;
1800 glyphs[text_info->length].font_size =
1801 render_priv->state.font_size * render_priv->font_scale;
1802 glyphs[text_info->length].be = render_priv->state.be;
1803 glyphs[text_info->length].blur = render_priv->state.blur;
1804 glyphs[text_info->length].shadow_x = render_priv->state.shadow_x;
1805 glyphs[text_info->length].shadow_y = render_priv->state.shadow_y;
1806 glyphs[text_info->length].scale_x= render_priv->state.scale_x;
1807 glyphs[text_info->length].scale_y = render_priv->state.scale_y;
1808 glyphs[text_info->length].border_style = render_priv->state.border_style;
1809 glyphs[text_info->length].border_x= render_priv->state.border_x;
1810 glyphs[text_info->length].border_y = render_priv->state.border_y;
1811 glyphs[text_info->length].hspacing = render_priv->state.hspacing;
1812 glyphs[text_info->length].bold = render_priv->state.bold;
1813 glyphs[text_info->length].italic = render_priv->state.italic;
1814 glyphs[text_info->length].flags = render_priv->state.flags;
1815 glyphs[text_info->length].frx = render_priv->state.frx;
1816 glyphs[text_info->length].fry = render_priv->state.fry;
1817 glyphs[text_info->length].frz = render_priv->state.frz;
1818 glyphs[text_info->length].fax = render_priv->state.fax;
1819 glyphs[text_info->length].fay = render_priv->state.fay;
1820 glyphs[text_info->length].bm_run_id = render_priv->state.bm_run_id;
1821
1822 if (glyphs[text_info->length].drawing) {
1823 drawing = render_priv->state.drawing =
1824 ass_drawing_new(render_priv->library, render_priv->ftlibrary);
1825 }
1826
1827 text_info->length++;
1828
1829 render_priv->state.effect_type = EF_NONE;
1830 render_priv->state.effect_timing = 0;
1831 render_priv->state.effect_skip_timing = 0;
1832
1833 }
1834
1835 if (text_info->length == 0) {
1836 // no valid symbols in the event; this can be smth like {comment}
1837 free_render_context(render_priv);
1838 return 1;
1839 }
1840
1841 // Find shape runs and shape text
1842 ass_shaper_set_base_direction(render_priv->shaper,
1843 resolve_base_direction(render_priv->state.font_encoding));
1844 ass_shaper_find_runs(render_priv->shaper, render_priv, glyphs,
1845 text_info->length);
1846 ass_shaper_shape(render_priv->shaper, text_info);
1847
1848 // Retrieve glyphs
1849 for (i = 0; i < text_info->length; i++) {
1850 GlyphInfo *info = glyphs + i;
1851 while (info) {
1852 get_outline_glyph(render_priv, info);
1853 info = info->next;
1854 }
1855 info = glyphs + i;
1856
1857 // Add additional space after italic to non-italic style changes
1858 if (i && glyphs[i - 1].italic && !info->italic) {
1859 int back = i - 1;
1860 GlyphInfo *og = &glyphs[back];
1861 while (back && og->bbox.xMax - og->bbox.xMin == 0
1862 && og->italic)
1863 og = &glyphs[--back];
1864 if (og->bbox.xMax > og->cluster_advance.x)
1865 og->cluster_advance.x = og->bbox.xMax;
1866 }
1867
1868 // add horizontal letter spacing
1869 info->cluster_advance.x += double_to_d6(info->hspacing *
1870 render_priv->font_scale * info->scale_x);
1871
1872 // add displacement for vertical shearing
1873 info->cluster_advance.y += (info->fay / info->scale_x * info->scale_y) * info->cluster_advance.x;
1874
1875 }
1876
1877 // Preliminary layout (for line wrapping)
1878 previous = 0;
1879 pen.x = 0;
1880 pen.y = 0;
1881 for (i = 0; i < text_info->length; i++) {
1882 GlyphInfo *info = glyphs + i;
1883 FT_Vector cluster_pen = pen;
1884 while (info) {
1885 info->pos.x = cluster_pen.x;
1886 info->pos.y = cluster_pen.y;
1887
1888 cluster_pen.x += info->advance.x;
1889 cluster_pen.y += info->advance.y;
1890
1891 // fill bitmap hash
1892 info->hash_key.type = BITMAP_OUTLINE;
1893 fill_bitmap_hash(render_priv, info, &info->hash_key.u.outline);
1894
1895 info = info->next;
1896 }
1897 info = glyphs + i;
1898 pen.x += info->cluster_advance.x;
1899 pen.y += info->cluster_advance.y;
1900 previous = info->symbol;
1901 }
1902
1903
1904 // depends on glyph x coordinates being monotonous, so it should be done before line wrap
1905 process_karaoke_effects(render_priv);
1906
1907 // alignments
1908 alignment = render_priv->state.alignment;
1909 halign = alignment & 3;
1910 valign = alignment & 12;
1911
1912 MarginL =
1913 (event->MarginL) ? event->MarginL : render_priv->state.style->MarginL;
1914 MarginR =
1915 (event->MarginR) ? event->MarginR : render_priv->state.style->MarginR;
1916 MarginV =
1917 (event->MarginV) ? event->MarginV : render_priv->state.style->MarginV;
1918
1919 // calculate max length of a line
1920 double max_text_width =
1921 x2scr(render_priv, render_priv->track->PlayResX - MarginR) -
1922 x2scr(render_priv, MarginL);
1923
1924 // wrap lines
1925 if (render_priv->state.evt_type != EVENT_HSCROLL) {
1926 // rearrange text in several lines
1927 wrap_lines_smart(render_priv, max_text_width);
1928 } else {
1929 // no breaking or wrapping, everything in a single line
1930 text_info->lines[0].offset = 0;
1931 text_info->lines[0].len = text_info->length;
1932 text_info->n_lines = 1;
1933 measure_text(render_priv);
1934 }
1935
1936 // Reorder text into visual order
1937 FriBidiStrIndex *cmap = ass_shaper_reorder(render_priv->shaper, text_info);
1938
1939 // Reposition according to the map
1940 pen.x = 0;
1941 pen.y = 0;
1942 int lineno = 1;
1943 for (i = 0; i < text_info->length; i++) {
1944 GlyphInfo *info = glyphs + cmap[i];
1945 if (glyphs[i].linebreak) {
1946 pen.y -= (info->fay / info->scale_x * info->scale_y) * pen.x;
1947 pen.x = 0;
1948 pen.y += double_to_d6(text_info->lines[lineno-1].desc);
1949 pen.y += double_to_d6(text_info->lines[lineno].asc);
1950 pen.y += double_to_d6(render_priv->settings.line_spacing);
1951 lineno++;
1952 }
1953 if (info->skip) continue;
1954 FT_Vector cluster_pen = pen;
1955 while (info) {
1956 info->pos.x = info->offset.x + cluster_pen.x;
1957 info->pos.y = info->offset.y + cluster_pen.y;
1958 cluster_pen.x += info->advance.x;
1959 cluster_pen.y += info->advance.y;
1960 info = info->next;
1961 }
1962 info = glyphs + cmap[i];
1963 pen.x += info->cluster_advance.x;
1964 pen.y += info->cluster_advance.y;
1965 }
1966
1967 // align lines
1968 if (render_priv->state.evt_type != EVENT_HSCROLL) {
1969 last_break = -1;
1970 double width = 0;
1971 for (i = 0; i <= text_info->length; ++i) { // (text_info->length + 1) is the end of the last line
1972 if ((i == text_info->length) || glyphs[i].linebreak) {
1973 // remove letter spacing (which is included in cluster_advance)
1974 if (i > 0)
1975 width -= render_priv->state.hspacing * render_priv->font_scale *
1976 glyphs[i-1].scale_x;
1977 double shift = 0;
1978 if (halign == HALIGN_LEFT) { // left aligned, no action
1979 shift = 0;
1980 } else if (halign == HALIGN_RIGHT) { // right aligned
1981 shift = max_text_width - width;
1982 } else if (halign == HALIGN_CENTER) { // centered
1983 shift = (max_text_width - width) / 2.0;
1984 }
1985 for (j = last_break + 1; j < i; ++j) {
1986 GlyphInfo *info = glyphs + j;
1987 while (info) {
1988 info->pos.x += double_to_d6(shift);
1989 info = info->next;
1990 }
1991 }
1992 last_break = i - 1;
1993 width = 0;
1994 }
1995 if (i < text_info->length && !glyphs[i].skip &&
1996 glyphs[i].symbol != '\n' && glyphs[i].symbol != 0) {
1997 width += d6_to_double(glyphs[i].cluster_advance.x);
1998 }
1999 }
2000 }
2001
2002 // determing text bounding box
2003 compute_string_bbox(text_info, &bbox);
2004
2005 // determine device coordinates for text
2006
2007 // x coordinate for everything except positioned events
2008 if (render_priv->state.evt_type == EVENT_NORMAL ||
2009 render_priv->state.evt_type == EVENT_VSCROLL) {
2010 device_x = x2scr(render_priv, MarginL);
2011 } else if (render_priv->state.evt_type == EVENT_HSCROLL) {
2012 if (render_priv->state.scroll_direction == SCROLL_RL)
2013 device_x =
2014 x2scr(render_priv,
2015 render_priv->track->PlayResX -
2016 render_priv->state.scroll_shift);
2017 else if (render_priv->state.scroll_direction == SCROLL_LR)
2018 device_x =
2019 x2scr(render_priv,
2020 render_priv->state.scroll_shift) - (bbox.xMax -
2021 bbox.xMin);
2022 }
2023
2024 // y coordinate for everything except positioned events
2025 if (render_priv->state.evt_type == EVENT_NORMAL ||
2026 render_priv->state.evt_type == EVENT_HSCROLL) {
2027 if (valign == VALIGN_TOP) { // toptitle
2028 device_y =
2029 y2scr_top(render_priv,
2030 MarginV) + text_info->lines[0].asc;
2031 } else if (valign == VALIGN_CENTER) { // midtitle
2032 double scr_y =
2033 y2scr(render_priv, render_priv->track->PlayResY / 2.0);
2034 device_y = scr_y - (bbox.yMax + bbox.yMin) / 2.0;
2035 } else { // subtitle
2036 double scr_top, scr_bottom, scr_y0;
2037 if (valign != VALIGN_SUB)
2038 ass_msg(render_priv->library, MSGL_V,
2039 "Invalid valign, assuming 0 (subtitle)");
2040 scr_bottom =
2041 y2scr_sub(render_priv,
2042 render_priv->track->PlayResY - MarginV);
2043 scr_top = y2scr_top(render_priv, 0); //xxx not always 0?
2044 device_y = scr_bottom + (scr_top - scr_bottom) *
2045 render_priv->settings.line_position / 100.0;
2046 device_y -= text_info->height;
2047 device_y += text_info->lines[0].asc;
2048 // clip to top to avoid confusion if line_position is very high,
2049 // turning the subtitle into a toptitle
2050 // also, don't change behavior if line_position is not used
2051 scr_y0 = scr_top + text_info->lines[0].asc;
2052 if (device_y < scr_y0 && render_priv->settings.line_position > 0) {
2053 device_y = scr_y0;
2054 }
2055 }
2056 } else if (render_priv->state.evt_type == EVENT_VSCROLL) {
2057 if (render_priv->state.scroll_direction == SCROLL_TB)
2058 device_y =
2059 y2scr(render_priv,
2060 render_priv->state.clip_y0 +
2061 render_priv->state.scroll_shift) - (bbox.yMax -
2062 bbox.yMin);
2063 else if (render_priv->state.scroll_direction == SCROLL_BT)
2064 device_y =
2065 y2scr(render_priv,
2066 render_priv->state.clip_y1 -
2067 render_priv->state.scroll_shift);
2068 }
2069
2070 // positioned events are totally different
2071 if (render_priv->state.evt_type == EVENT_POSITIONED) {
2072 double base_x = 0;
2073 double base_y = 0;
2074 ass_msg(render_priv->library, MSGL_DBG2, "positioned event at %f, %f",
2075 render_priv->state.pos_x, render_priv->state.pos_y);
2076 get_base_point(&bbox, alignment, &base_x, &base_y);
2077 device_x =
2078 x2scr_pos(render_priv, render_priv->state.pos_x) - base_x;
2079 device_y =
2080 y2scr_pos(render_priv, render_priv->state.pos_y) - base_y;
2081 }
2082
2083 // fix clip coordinates (they depend on alignment)
2084 if (render_priv->state.evt_type == EVENT_NORMAL ||
2085 render_priv->state.evt_type == EVENT_HSCROLL ||
2086 render_priv->state.evt_type == EVENT_VSCROLL) {
2087 render_priv->state.clip_x0 =
2088 x2scr_scaled(render_priv, render_priv->state.clip_x0);
2089 render_priv->state.clip_x1 =
2090 x2scr_scaled(render_priv, render_priv->state.clip_x1);
2091 if (valign == VALIGN_TOP) {
2092 render_priv->state.clip_y0 =
2093 y2scr_top(render_priv, render_priv->state.clip_y0);
2094 render_priv->state.clip_y1 =
2095 y2scr_top(render_priv, render_priv->state.clip_y1);
2096 } else if (valign == VALIGN_CENTER) {
2097 render_priv->state.clip_y0 =
2098 y2scr(render_priv, render_priv->state.clip_y0);
2099 render_priv->state.clip_y1 =
2100 y2scr(render_priv, render_priv->state.clip_y1);
2101 } else if (valign == VALIGN_SUB) {
2102 render_priv->state.clip_y0 =
2103 y2scr_sub(render_priv, render_priv->state.clip_y0);
2104 render_priv->state.clip_y1 =
2105 y2scr_sub(render_priv, render_priv->state.clip_y1);
2106 }
2107 } else if (render_priv->state.evt_type == EVENT_POSITIONED) {
2108 render_priv->state.clip_x0 =
2109 x2scr_pos_scaled(render_priv, render_priv->state.clip_x0);
2110 render_priv->state.clip_x1 =
2111 x2scr_pos_scaled(render_priv, render_priv->state.clip_x1);
2112 render_priv->state.clip_y0 =
2113 y2scr_pos(render_priv, render_priv->state.clip_y0);
2114 render_priv->state.clip_y1 =
2115 y2scr_pos(render_priv, render_priv->state.clip_y1);
2116 }
2117
2118 // calculate rotation parameters
2119 {
2120 DVector center;
2121
2122 if (render_priv->state.have_origin) {
2123 center.x = x2scr(render_priv, render_priv->state.org_x);
2124 center.y = y2scr(render_priv, render_priv->state.org_y);
2125 } else {
2126 double bx = 0., by = 0.;
2127 get_base_point(&bbox, alignment, &bx, &by);
2128 center.x = device_x + bx;
2129 center.y = device_y + by;
2130 }
2131
2132 for (i = 0; i < text_info->length; ++i) {
2133 GlyphInfo *info = glyphs + i;
2134 while (info) {
2135 OutlineBitmapHashKey *key = &info->hash_key.u.outline;
2136
2137 if (key->frx || key->fry || key->frz || key->fax || key->fay) {
2138 key->shift_x = info->pos.x + double_to_d6(device_x - center.x);
2139 key->shift_y = -(info->pos.y + double_to_d6(device_y - center.y));
2140 } else {
2141 key->shift_x = 0;
2142 key->shift_y = 0;
2143 }
2144 info = info->next;
2145 }
2146 }
2147 }
2148
2149 // convert glyphs to bitmaps
2150 int left = render_priv->settings.left_margin;
2151 device_x = (device_x - left) * render_priv->font_scale_x + left;
2152 for (i = 0; i < text_info->length; ++i) {
2153 GlyphInfo *info = glyphs + i;
2154 while (info) {
2155 OutlineBitmapHashKey *key = &info->hash_key.u.outline;
2156 info->pos.x *= render_priv->font_scale_x;
2157 key->advance.x =
2158 double_to_d6(device_x - (int) device_x +
2159 d6_to_double(info->pos.x & SUBPIXEL_MASK)) & ~SUBPIXEL_ACCURACY;
2160 key->advance.y =
2161 double_to_d6(device_y - (int) device_y +
2162 d6_to_double(info->pos.y & SUBPIXEL_MASK)) & ~SUBPIXEL_ACCURACY;
2163 get_bitmap_glyph(render_priv, info);
2164 info = info->next;
2165 }
2166 }
2167
2168 memset(event_images, 0, sizeof(*event_images));
2169 event_images->top = device_y - text_info->lines[0].asc;
2170 event_images->height = text_info->height;
2171 event_images->left =
2172 (device_x + bbox.xMin * render_priv->font_scale_x) + 0.5;
2173 event_images->width =
2174 (bbox.xMax - bbox.xMin) * render_priv->font_scale_x + 0.5;
2175 event_images->detect_collisions = render_priv->state.detect_collisions;
2176 event_images->shift_direction = (valign == VALIGN_TOP) ? 1 : -1;
2177 event_images->event = event;
2178 event_images->imgs = render_text(render_priv, (int) device_x, (int) device_y);
2179
2180 ass_shaper_cleanup(render_priv->shaper, text_info);
2181 free_render_context(render_priv);
2182
2183 return 0;
2184 }
2185
2186 /**
2187 * \brief deallocate image list
2188 * \param img list pointer
2189 */
2190 void ass_free_images(ASS_Image *img)
2191 {
2192 while (img) {
2193 ASS_Image *next = img->next;
2194 free(img);
2195 img = next;
2196 }
2197 }
2198
2199 /**
2200 * \brief Check cache limits and reset cache if they are exceeded
2201 */
2202 static void check_cache_limits(ASS_Renderer *priv, CacheStore *cache)
2203 {
2204 if (ass_cache_empty(cache->bitmap_cache, cache->bitmap_max_size)) {
2205 ass_cache_empty(cache->composite_cache, 0);
2206 ass_free_images(priv->prev_images_root);
2207 priv->prev_images_root = 0;
2208 priv->cache_cleared = 1;
2209 }
2210 if (ass_cache_empty(cache->outline_cache, cache->glyph_max)) {
2211 ass_cache_empty(cache->bitmap_cache, 0);
2212 ass_cache_empty(cache->composite_cache, 0);
2213 ass_free_images(priv->prev_images_root);
2214 priv->prev_images_root = 0;
2215 priv->cache_cleared = 1;
2216 }
2217 }
2218
2219 /**
2220 * \brief Start a new frame
2221 */
2222 static int
2223 ass_start_frame(ASS_Renderer *render_priv, ASS_Track *track,
2224 long long now)
2225 {
2226 ASS_Settings *settings_priv = &render_priv->settings;
2227
2228 if (!render_priv->settings.frame_width
2229 && !render_priv->settings.frame_height)
2230 return 1; // library not initialized
2231
2232 if (render_priv->library != track->library)
2233 return 1;
2234
2235 if (!render_priv->fontconfig_priv)
2236 return 1;
2237
2238 free_list_clear(render_priv);
2239
2240 if (track->n_events == 0)
2241 return 1; // nothing to do
2242
2243 render_priv->track = track;
2244 render_priv->time = now;
2245
2246 ass_lazy_track_init(render_priv->library, render_priv->track);
2247
2248 render_priv->font_scale = settings_priv->font_size_coeff *
2249 render_priv->orig_height / render_priv->track->PlayResY;
2250 if (render_priv->track->ScaledBorderAndShadow)
2251 render_priv->border_scale =
2252 ((double) render_priv->orig_height) /
2253 render_priv->track->PlayResY;
2254 else
2255 render_priv->border_scale = 1.;
2256
2257 ass_shaper_set_kerning(render_priv->shaper, track->Kerning);
2258 if (track->Language)
2259 ass_shaper_set_language(render_priv->shaper, track->Language);
2260 ass_shaper_set_level(render_priv->shaper, render_priv->settings.shaper);
2261
2262 // PAR correction
2263 render_priv->font_scale_x = render_priv->settings.aspect /
2264 render_priv->settings.storage_aspect;
2265
2266 render_priv->prev_images_root = render_priv->images_root;
2267 render_priv->images_root = 0;
2268
2269 check_cache_limits(render_priv, &render_priv->cache);
2270
2271 return 0;
2272 }
2273
2274 static int cmp_event_layer(const void *p1, const void *p2)
2275 {
2276 ASS_Event *e1 = ((EventImages *) p1)->event;
2277 ASS_Event *e2 = ((EventImages *) p2)->event;
2278 if (e1->Layer < e2->Layer)
2279 return -1;
2280 if (e1->Layer > e2->Layer)
2281 return 1;
2282 if (e1->ReadOrder < e2->ReadOrder)
2283 return -1;
2284 if (e1->ReadOrder > e2->ReadOrder)
2285 return 1;
2286 return 0;
2287 }
2288
2289 static ASS_RenderPriv *get_render_priv(ASS_Renderer *render_priv,
2290 ASS_Event *event)
2291 {
2292 if (!event->render_priv)
2293 event->render_priv = calloc(1, sizeof(ASS_RenderPriv));
2294 if (render_priv->render_id != event->render_priv->render_id) {
2295 memset(event->render_priv, 0, sizeof(ASS_RenderPriv));
2296 event->render_priv->render_id = render_priv->render_id;
2297 }
2298
2299 return event->render_priv;
2300 }
2301
2302 static int overlap(Segment *s1, Segment *s2)
2303 {
2304 if (s1->a >= s2->b || s2->a >= s1->b ||
2305 s1->ha >= s2->hb || s2->ha >= s1->hb)
2306 return 0;
2307 return 1;
2308 }
2309
2310 static int cmp_segment(const void *p1, const void *p2)
2311 {
2312 return ((Segment *) p1)->a - ((Segment *) p2)->a;
2313 }
2314
2315 static void
2316 shift_event(ASS_Renderer *render_priv, EventImages *ei, int shift)
2317 {
2318 ASS_Image *cur = ei->imgs;
2319 while (cur) {
2320 cur->dst_y += shift;
2321 // clip top and bottom
2322 if (cur->dst_y < 0) {
2323 int clip = -cur->dst_y;
2324 cur->h -= clip;
2325 cur->bitmap += clip * cur->stride;
2326 cur->dst_y = 0;
2327 }
2328 if (cur->dst_y + cur->h >= render_priv->height) {
2329 int clip = cur->dst_y + cur->h - render_priv->height;
2330 cur->h -= clip;
2331 }
2332 if (cur->h <= 0) {
2333 cur->h = 0;
2334 cur->dst_y = 0;
2335 }
2336 cur = cur->next;
2337 }
2338 ei->top += shift;
2339 }
2340
2341 // dir: 1 - move down
2342 // -1 - move up
2343 static int fit_segment(Segment *s, Segment *fixed, int *cnt, int dir)
2344 {
2345 int i;
2346 int shift = 0;
2347
2348 if (dir == 1) // move down
2349 for (i = 0; i < *cnt; ++i) {
2350 if (s->b + shift <= fixed[i].a || s->a + shift >= fixed[i].b ||
2351 s->hb <= fixed[i].ha || s->ha >= fixed[i].hb)
2352 continue;
2353 shift = fixed[i].b - s->a;
2354 } else // dir == -1, move up
2355 for (i = *cnt - 1; i >= 0; --i) {
2356 if (s->b + shift <= fixed[i].a || s->a + shift >= fixed[i].b ||
2357 s->hb <= fixed[i].ha || s->ha >= fixed[i].hb)
2358 continue;
2359 shift = fixed[i].a - s->b;
2360 }
2361
2362 fixed[*cnt].a = s->a + shift;
2363 fixed[*cnt].b = s->b + shift;
2364 fixed[*cnt].ha = s->ha;
2365 fixed[*cnt].hb = s->hb;
2366 (*cnt)++;
2367 qsort(fixed, *cnt, sizeof(Segment), cmp_segment);
2368
2369 return shift;
2370 }
2371
2372 static void
2373 fix_collisions(ASS_Renderer *render_priv, EventImages *imgs, int cnt)
2374 {
2375 Segment *used = malloc(cnt * sizeof(*used));
2376 int cnt_used = 0;
2377 int i, j;
2378
2379 // fill used[] with fixed events
2380 for (i = 0; i < cnt; ++i) {
2381 ASS_RenderPriv *priv;
2382 if (!imgs[i].detect_collisions)
2383 continue;
2384 priv = get_render_priv(render_priv, imgs[i].event);
2385 if (priv->height > 0) { // it's a fixed event
2386 Segment s;
2387 s.a = priv->top;
2388 s.b = priv->top + priv->height;
2389 s.ha = priv->left;
2390 s.hb = priv->left + priv->width;
2391 if (priv->height != imgs[i].height) { // no, it's not
2392 ass_msg(render_priv->library, MSGL_WARN,
2393 "Event height has changed");
2394 priv->top = 0;
2395 priv->height = 0;
2396 priv->left = 0;
2397 priv->width = 0;
2398 }
2399 for (j = 0; j < cnt_used; ++j)
2400 if (overlap(&s, used + j)) { // no, it's not
2401 priv->top = 0;
2402 priv->height = 0;
2403 priv->left = 0;
2404 priv->width = 0;
2405 }
2406 if (priv->height > 0) { // still a fixed event
2407 used[cnt_used].a = priv->top;
2408 used[cnt_used].b = priv->top + priv->height;
2409 used[cnt_used].ha = priv->left;
2410 used[cnt_used].hb = priv->left + priv->width;
2411 cnt_used++;
2412 shift_event(render_priv, imgs + i, priv->top - imgs[i].top);
2413 }
2414 }
2415 }
2416 qsort(used, cnt_used, sizeof(Segment), cmp_segment);
2417
2418 // try to fit other events in free spaces
2419 for (i = 0; i < cnt; ++i) {
2420 ASS_RenderPriv *priv;
2421 if (!imgs[i].detect_collisions)
2422 continue;
2423 priv = get_render_priv(render_priv, imgs[i].event);
2424 if (priv->height == 0) { // not a fixed event
2425 int shift;
2426 Segment s;
2427 s.a = imgs[i].top;
2428 s.b = imgs[i].top + imgs[i].height;
2429 s.ha = imgs[i].left;
2430 s.hb = imgs[i].left + imgs[i].width;
2431 shift = fit_segment(&s, used, &cnt_used, imgs[i].shift_direction);
2432 if (shift)
2433 shift_event(render_priv, imgs + i, shift);
2434 // make it fixed
2435 priv->top = imgs[i].top;
2436 priv->height = imgs[i].height;
2437 priv->left = imgs[i].left;
2438 priv->width = imgs[i].width;
2439 }
2440
2441 }
2442
2443 free(used);
2444 }
2445
2446 /**
2447 * \brief compare two images
2448 * \param i1 first image
2449 * \param i2 second image
2450 * \return 0 if identical, 1 if different positions, 2 if different content
2451 */
2452 static int ass_image_compare(ASS_Image *i1, ASS_Image *i2)
2453 {
2454 if (i1->w != i2->w)
2455 return 2;
2456 if (i1->h != i2->h)
2457 return 2;
2458 if (i1->stride != i2->stride)
2459 return 2;
2460 if (i1->color != i2->color)
2461 return 2;
2462 if (i1->bitmap != i2->bitmap)
2463 return 2;
2464 if (i1->dst_x != i2->dst_x)
2465 return 1;
2466 if (i1->dst_y != i2->dst_y)
2467 return 1;
2468 return 0;
2469 }
2470
2471 /**
2472 * \brief compare current and previous image list
2473 * \param priv library handle
2474 * \return 0 if identical, 1 if different positions, 2 if different content
2475 */
2476 static int ass_detect_change(ASS_Renderer *priv)
2477 {
2478 ASS_Image *img, *img2;
2479 int diff;
2480
2481 if (priv->cache_cleared)
2482 return 2;
2483
2484 img = priv->prev_images_root;
2485 img2 = priv->images_root;
2486 diff = 0;
2487 while (img && diff < 2) {
2488 ASS_Image *next, *next2;
2489 next = img->next;
2490 if (img2) {
2491 int d = ass_image_compare(img, img2);
2492 if (d > diff)
2493 diff = d;
2494 next2 = img2->next;
2495 } else {
2496 // previous list is shorter
2497 diff = 2;
2498 break;
2499 }
2500 img = next;
2501 img2 = next2;
2502 }
2503
2504 // is the previous list longer?
2505 if (img2)
2506 diff = 2;
2507
2508 return diff;
2509 }
2510
2511 /**
2512 * \brief render a frame
2513 * \param priv library handle
2514 * \param track track
2515 * \param now current video timestamp (ms)
2516 * \param detect_change a value describing how the new images differ from the previous ones will be written here:
2517 * 0 if identical, 1 if different positions, 2 if different content.
2518 * Can be NULL, in that case no detection is performed.
2519 */
2520 ASS_Image *ass_render_frame(ASS_Renderer *priv, ASS_Track *track,
2521 long long now, int *detect_change)
2522 {
2523 int i, cnt, rc;
2524 EventImages *last;
2525 ASS_Image **tail;
2526
2527 // init frame
2528 rc = ass_start_frame(priv, track, now);
2529 if (rc != 0) {
2530 if (detect_change) {
2531 *detect_change = 2;
2532 }
2533 return 0;
2534 }
2535
2536 // render events separately
2537 cnt = 0;
2538 for (i = 0; i < track->n_events; ++i) {
2539 ASS_Event *event = track->events + i;
2540 if ((event->Start <= now)
2541 && (now < (event->Start + event->Duration))) {
2542 if (cnt >= priv->eimg_size) {
2543 priv->eimg_size += 100;
2544 priv->eimg =
2545 realloc(priv->eimg,
2546 priv->eimg_size * sizeof(EventImages));
2547 }
2548 rc = ass_render_event(priv, event, priv->eimg + cnt);
2549 if (!rc)
2550 ++cnt;
2551 }
2552 }
2553
2554 // sort by layer
2555 qsort(priv->eimg, cnt, sizeof(EventImages), cmp_event_layer);
2556
2557 // call fix_collisions for each group of events with the same layer
2558 last = priv->eimg;
2559 for (i = 1; i < cnt; ++i)
2560 if (last->event->Layer != priv->eimg[i].event->Layer) {
2561 fix_collisions(priv, last, priv->eimg + i - last);
2562 last = priv->eimg + i;
2563 }
2564 if (cnt > 0)
2565 fix_collisions(priv, last, priv->eimg + cnt - last);
2566
2567 // concat lists
2568 tail = &priv->images_root;
2569 for (i = 0; i < cnt; ++i) {
2570 ASS_Image *cur = priv->eimg[i].imgs;
2571 while (cur) {
2572 *tail = cur;
2573 tail = &cur->next;
2574 cur = cur->next;
2575 }
2576 }
2577
2578 if (detect_change)
2579 *detect_change = ass_detect_change(priv);
2580
2581 // free the previous image list
2582 ass_free_images(priv->prev_images_root);
2583 priv->prev_images_root = 0;
2584 priv->cache_cleared = 0;
2585
2586 return priv->images_root;
2587 }