cinelerra-5.1/plugins/titler/title.C

   1
   2 /*
   3  * CINELERRA
   4  * Copyright (C) 1997-2014 Adam Williams <broadcast at earthling dot net>
   5  *
   6  * This program is free software; you can redistribute it and/or modify
   7  * it under the terms of the GNU General Public License as published by
   8  * the Free Software Foundation; either version 2 of the License, or
   9  * (at your option) any later version.
  10  *
  11  * This program is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14  * GNU General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU General Public License
  17  * along with this program; if not, write to the Free Software
  18  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  19  *
  20  */
  21
  22 // Originally developed by Heroine Virtual Ltd.
  23 // Support for multiple encodings, outline (stroke) by
  24 // Andraz Tori <Andraz.tori1@guest.arnes.si>
  25 // Additional support for UTF-8 by
  26 // Paolo Rampino aka Akirad <info at tuttoainternet.it>
  27
  28
  29
  30
  31 #include "bcsignals.h"
  32 #include "clip.h"
  33 #include "bccmodels.h"
  34 #include "filexml.h"
  35 #include "filesystem.h"
  36 #include "transportque.inc"
  37 #include "ft2build.h"
  38 #include FT_GLYPH_H
  39 #include FT_BBOX_H
  40 #include FT_OUTLINE_H
  41 #include FT_STROKER_H
  42 #include "language.h"
  43 #include "mwindow.inc"
  44 #include "cicolors.h"
  45 #include "title.h"
  46 #include "titlewindow.h"
  47 #include "transportque.inc"
  48
  49
  50 #include <errno.h>
  51 #include <stdint.h>
  52 #include <stdio.h>
  53 #include <string.h>
  54 #include <endian.h>
  55 #include <byteswap.h>
  56 #include <iconv.h>
  57 #include <sys/stat.h>
  58 #include <fontconfig/fontconfig.h>
  59
  60 #define ZERO (1.0 / 64.0)
  61
  62 REGISTER_PLUGIN(TitleMain)
  63
  64 #ifdef X_HAVE_UTF8_STRING
  65 #define DEFAULT_ENCODING "UTF-8"
  66 #else
  67 #define DEFAULT_ENCODING "ISO8859-1"
  68 #endif
  69 #define DEFAULT_TIMECODEFORMAT TIME_HMS
  70
  71 static YUV yuv;
  72
  73 TitleConfig::TitleConfig()
  74 {
  75         style = 0;
  76         color = BLACK;
  77         alpha = 0xff;
  78         outline_alpha = 0xff;
  79         size = 24;
  80         motion_strategy = NO_MOTION;
  81         loop = 0;
  82         line_pitch = 0;
  83         hjustification = JUSTIFY_CENTER;
  84         vjustification = JUSTIFY_MID;
  85         fade_in = 0.0;
  86         fade_out = 0.0;
  87         x = 0.0;
  88         y = 0.0;
  89         dropshadow = 2;
  90         sprintf(font, "fixed");
  91         sprintf(encoding, DEFAULT_ENCODING);
  92         timecode_format = DEFAULT_TIMECODEFORMAT;
  93         pixels_per_second = 1.0;
  94         timecode = 0;
  95         stroke_width = 1.0;
  96         wtext[0] = 0;  wlen = 0;
  97         color_stroke = 0xff0000;
  98         outline_color = WHITE;
  99
 100         outline_size = 0;
 101         window_w = 640;
 102         window_h = 480;
 103         next_keyframe_position = 0;
 104         prev_keyframe_position = 0;
 105 }
 106
 107 TitleConfig::~TitleConfig()
 108 {
 109 }
 110
 111 // Does not test equivalency but determines if redrawing text is necessary.
 112 int TitleConfig::equivalent(TitleConfig &that)
 113 {
 114         return dropshadow == that.dropshadow &&
 115                 style == that.style &&
 116                 size == that.size &&
 117                 color == that.color &&
 118                 color_stroke == that.color_stroke &&
 119                 stroke_width == that.stroke_width &&
 120                 outline_color == that.outline_color &&
 121                 alpha == that.alpha &&
 122                 outline_alpha == that.outline_alpha &&
 123                 timecode == that.timecode &&
 124                 timecode_format == that.timecode_format &&
 125                 line_pitch == that.line_pitch &&
 126                 outline_size == that.outline_size &&
 127                 hjustification == that.hjustification &&
 128                 vjustification == that.vjustification &&
 129                 EQUIV(pixels_per_second, that.pixels_per_second) &&
 130                 !strcasecmp(font, that.font) &&
 131                 !strcasecmp(encoding, that.encoding) &&
 132                 wlen == that.wlen &&
 133                 !memcmp(wtext, that.wtext, wlen * sizeof(wchar_t));
 134 }
 135
 136 void TitleConfig::copy_from(TitleConfig &that)
 137 {
 138         strcpy(font, that.font);
 139         style = that.style;
 140         size = that.size;
 141         color = that.color;
 142         color_stroke = that.color_stroke;
 143         stroke_width = that.stroke_width;
 144         outline_color = that.outline_color;
 145         alpha = that.alpha;
 146         outline_alpha = that.outline_alpha;
 147         pixels_per_second = that.pixels_per_second;
 148         motion_strategy = that.motion_strategy;
 149         loop = that.loop;
 150         line_pitch = that.line_pitch;
 151         hjustification = that.hjustification;
 152         vjustification = that.vjustification;
 153         fade_in = that.fade_in;
 154         fade_out = that.fade_out;
 155         x = that.x;
 156         y = that.y;
 157         dropshadow = that.dropshadow;
 158         timecode = that.timecode;
 159         timecode_format = that.timecode_format;
 160         outline_size = that.outline_size;
 161         strcpy(encoding, that.encoding);
 162         memcpy(wtext, that.wtext, that.wlen * sizeof(wchar_t));
 163         wlen = that.wlen;
 164         window_w = that.window_w;
 165         window_h = that.window_h;
 166
 167         limits();
 168 }
 169
 170 void TitleConfig::interpolate(TitleConfig &prev,
 171         TitleConfig &next,
 172         int64_t prev_frame,
 173         int64_t next_frame,
 174         int64_t current_frame)
 175 {
 176         strcpy(font, prev.font);
 177         strcpy(encoding, prev.encoding);
 178         style = prev.style;
 179         size = prev.size;
 180         color = prev.color;
 181         color_stroke = prev.color_stroke;
 182         stroke_width = prev.stroke_width;
 183         outline_color = prev.outline_color;
 184         alpha = prev.alpha;
 185         outline_alpha = prev.outline_alpha;
 186         motion_strategy = prev.motion_strategy;
 187         loop = prev.loop;
 188         line_pitch = prev.line_pitch;
 189         hjustification = prev.hjustification;
 190         vjustification = prev.vjustification;
 191         fade_in = prev.fade_in;
 192         fade_out = prev.fade_out;
 193         outline_size = prev.outline_size;
 194         pixels_per_second = prev.pixels_per_second;
 195         memcpy(wtext, prev.wtext, prev.wlen * sizeof(wchar_t));
 196         wlen = prev.wlen;
 197         wtext[wlen] = 0;
 198
 199         double next_scale = (double)(current_frame - prev_frame) / (next_frame - prev_frame);
 200         double prev_scale = (double)(next_frame - current_frame) / (next_frame - prev_frame);
 201         this->x = prev.x * prev_scale + next.x * next_scale;
 202         this->y = prev.y * prev_scale + next.y * next_scale;
 203 //      this->x = prev.x;
 204 //      this->y = prev.y;
 205         timecode = prev.timecode;
 206         timecode_format = prev.timecode_format;
 207         this->dropshadow = prev.dropshadow * prev_scale + next.dropshadow * next_scale;
 208 //      this->dropshadow = prev.dropshadow;
 209 }
 210
 211 void TitleConfig::limits()
 212 {
 213         if(window_w < 100) window_w = 100;
 214         if(window_h < 100) window_h = 100;
 215 }
 216
 217
 218
 219
 220 void TitleConfig::to_wtext(const char *from_enc, const char *text, int tlen)
 221 {
 222         wlen = BC_Resources::encode(from_enc, BC_Resources::wide_encoding,
 223                 (char*)text,tlen, (char *)wtext,sizeof(wtext)) / sizeof(wchar_t);
 224         while( wlen > 0 && !wtext[wlen-1] ) --wlen;
 225 }
 226
 227
 228 TitleGlyph::TitleGlyph()
 229 {
 230         char_code = 0;
 231         data = 0;
 232         data_stroke = 0;
 233         freetype_index = 0;
 234         width = 0;
 235         height = 0;
 236         pitch = 0;
 237         left = 0;
 238         top = 0;
 239         bottom = 0;
 240         right = 0;
 241         advance_x = 0;
 242 }
 243
 244
 245 TitleGlyph::~TitleGlyph()
 246 {
 247 //printf("TitleGlyph::~TitleGlyph 1\n");
 248         if(data) delete data;
 249         if(data_stroke) delete data_stroke;
 250 }
 251
 252
 253
 254
 255
 256
 257
 258
 259
 260
 261
 262 GlyphPackage::GlyphPackage() : LoadPackage()
 263 {
 264         glyph = 0;
 265 }
 266
 267 GlyphUnit::GlyphUnit(TitleMain *plugin, GlyphEngine *server)
 268  : LoadClient(server)
 269 {
 270         this->plugin = plugin;
 271         current_font = 0;
 272         freetype_library = 0;
 273         freetype_face = 0;
 274 }
 275
 276 GlyphUnit::~GlyphUnit()
 277 {
 278         if(freetype_library)
 279                 FT_Done_FreeType(freetype_library);
 280 }
 281
 282 void GlyphUnit::process_package(LoadPackage *package)
 283 {
 284         GlyphPackage *pkg = (GlyphPackage*)package;
 285         TitleGlyph *glyph = pkg->glyph;
 286         int result = 0;
 287         char new_path[BCTEXTLEN];
 288
 289         current_font = plugin->get_font();
 290
 291         if(plugin->load_freetype_face(freetype_library, freetype_face,
 292                         current_font->path)) {
 293                 printf(_("GlyphUnit::process_package FT_New_Face failed.\n"));
 294                 result = 1;
 295         }
 296
 297         if(!result) {
 298                 int gindex = FT_Get_Char_Index(freetype_face, glyph->char_code);
 299
 300 //printf("GlyphUnit::process_package 1 %c\n", glyph->char_code);
 301 // Char not found
 302                 if(gindex == 0) {
 303                         BC_Resources *resources =  BC_WindowBase::get_resources();
 304                         // Search replacement font
 305                         if(resources->find_font_by_char(glyph->char_code, new_path, freetype_face))
 306                         {
 307                                 plugin->load_freetype_face(freetype_library,
 308                                         freetype_face, new_path);
 309                                 gindex = FT_Get_Char_Index(freetype_face, glyph->char_code);
 310                         }
 311                 }
 312                 FT_Set_Pixel_Sizes(freetype_face, plugin->config.size, 0);
 313
 314                 if (gindex == 0) {
 315 // carrige return
 316                         if (glyph->char_code != 10)
 317                                 printf(_("GlyphUnit::process_package FT_Load_Char failed - char: %li.\n"),
 318                                         glyph->char_code);
 319 // Prevent a crash here
 320                         glyph->width = 8;  glyph->height = 8;
 321                         glyph->pitch = 8;  glyph->advance_x = 8;
 322                         glyph->left = 9;   glyph->top = 9;
 323                         glyph->right = 0;  glyph->bottom = 0;
 324                         glyph->freetype_index = 0;
 325                         glyph->data = new VFrame(glyph->width, glyph->height, BC_A8, glyph->pitch);
 326                         glyph->data->clear_frame();
 327                         glyph->data_stroke = 0;
 328
 329 // create outline glyph
 330                         if (plugin->config.stroke_width >= ZERO &&
 331                                 (plugin->config.style & BC_FONT_OUTLINE)) {
 332                                 glyph->data_stroke = new VFrame(glyph->width, glyph->height, BC_A8, glyph->pitch);
 333                                 glyph->data_stroke->clear_frame();
 334                         }
 335                 }
 336 // char found and no outline desired
 337                 else if (plugin->config.stroke_width < ZERO ||
 338                         !(plugin->config.style & BC_FONT_OUTLINE)) {
 339                         FT_Glyph glyph_image;
 340                         FT_BBox bbox;
 341                         FT_Bitmap bm;
 342                         FT_Load_Glyph(freetype_face, gindex, FT_LOAD_DEFAULT);
 343                         FT_Get_Glyph(freetype_face->glyph, &glyph_image);
 344                         FT_Outline_Get_BBox(&((FT_OutlineGlyph) glyph_image)->outline, &bbox);
 345 //                      printf("Stroke: Xmin: %ld, Xmax: %ld, Ymin: %ld, yMax: %ld\n",
 346 //                                      bbox.xMin,bbox.xMax, bbox.yMin, bbox.yMax);
 347
 348                         glyph->width = bm.width = ((bbox.xMax - bbox.xMin + 63) >> 6);
 349                         glyph->height = bm.rows = ((bbox.yMax - bbox.yMin + 63) >> 6);
 350                         glyph->pitch = bm.pitch = bm.width;
 351                         bm.pixel_mode = FT_PIXEL_MODE_GRAY;
 352                         bm.num_grays = 256;
 353                         glyph->left = (bbox.xMin + 31) >> 6;
 354                         glyph->top = (bbox.yMax + 31) >> 6;
 355                         glyph->right = (bbox.xMax + 31) >> 6;
 356                         glyph->bottom = (bbox.yMin + 31) >> 6;
 357                         glyph->freetype_index = gindex;
 358                         glyph->advance_x = ((freetype_face->glyph->advance.x + 31) >> 6);
 359 //printf("GlyphUnit::process_package 1 width=%d height=%d pitch=%d left=%d top=%d advance_x=%d freetype_index=%d\n",
 360 //glyph->width, glyph->height, glyph->pitch, glyph->left, glyph->top, glyph->advance_x, glyph->freetype_index);
 361
 362                         glyph->data = new VFrame(glyph->width, glyph->height, BC_A8, glyph->pitch);
 363                         glyph->data->clear_frame();
 364                         bm.buffer = glyph->data->get_data();
 365                         FT_Outline_Translate(&((FT_OutlineGlyph) glyph_image)->outline,
 366                                 - bbox.xMin, - bbox.yMin);
 367                         FT_Outline_Get_Bitmap( freetype_library,
 368                                 &((FT_OutlineGlyph) glyph_image)->outline,
 369                                 &bm);
 370                         FT_Done_Glyph(glyph_image);
 371                 }
 372                 else {
 373 // Outline desired and glyph found
 374                         FT_Glyph glyph_image;
 375                         FT_Stroker stroker;
 376                         FT_Outline outline;
 377                         FT_Bitmap bm;
 378                         FT_BBox bbox;
 379                         FT_UInt npoints, ncontours;
 380
 381                         FT_Load_Glyph(freetype_face, gindex, FT_LOAD_DEFAULT);
 382                         FT_Get_Glyph(freetype_face->glyph, &glyph_image);
 383
 384 // check if the outline is ok (non-empty);
 385                         FT_Outline_Get_BBox(&((FT_OutlineGlyph) glyph_image)->outline, &bbox);
 386                         if( bbox.xMin == 0 && bbox.xMax == 0 &&
 387                             bbox.yMin == 0 && bbox.yMax == 0 ) {
 388                                 FT_Done_Glyph(glyph_image);
 389                                 glyph->width = 0;   glyph->height = 0;
 390                                 glyph->left = 0;    glyph->top = 0;
 391                                 glyph->right = 0;   glyph->bottom = 0;
 392                                 glyph->pitch = 0;
 393                                 glyph->data =
 394                                         new VFrame(glyph->width, glyph->height, BC_A8, glyph->pitch);
 395                                 glyph->data_stroke =
 396                                         new VFrame(glyph->width, glyph->height, BC_A8, glyph->pitch);
 397                                 glyph->advance_x =((int)(freetype_face->glyph->advance.x +
 398                                         plugin->config.stroke_width * 64)) >> 6;
 399                                 return;
 400                         }
 401 #if FREETYPE_MAJOR > 2 || (FREETYPE_MAJOR == 2 && FREETYPE_MINOR >= 2)
 402                         FT_Stroker_New(freetype_library, &stroker);
 403 #else
 404                         FT_Stroker_New(((FT_LibraryRec *)freetype_library)->memory, &stroker);
 405 #endif
 406                         FT_Stroker_Set(stroker, (int)(plugin->config.stroke_width * 64),
 407                                 FT_STROKER_LINECAP_ROUND, FT_STROKER_LINEJOIN_ROUND, 0);
 408                         FT_Stroker_ParseOutline(stroker, &((FT_OutlineGlyph) glyph_image)->outline,1);
 409                         FT_Stroker_GetCounts(stroker,&npoints, &ncontours);
 410                         if (npoints ==0 && ncontours == 0) {
 411 // this never happens, but FreeType has a bug regarding Linotype's Palatino font
 412                                 FT_Stroker_Done(stroker);
 413                                 FT_Done_Glyph(glyph_image);
 414                                 glyph->width = 0;   glyph->height = 0;
 415                                 glyph->left = 0;    glyph->top = 0;
 416                                 glyph->right = 0;   glyph->bottom = 0;
 417                                 glyph->pitch = 0;
 418                                 glyph->data =
 419                                         new VFrame(glyph->width, glyph->height, BC_A8, glyph->pitch);
 420                                 glyph->data_stroke =
 421                                         new VFrame(glyph->width, glyph->height, BC_A8, glyph->pitch);
 422                                 glyph->advance_x =((int)(freetype_face->glyph->advance.x +
 423                                         plugin->config.stroke_width * 64)) >> 6;
 424                                 return;
 425                         };
 426
 427                         FT_Outline_New(freetype_library, npoints, ncontours, &outline);
 428                         outline.n_points=0;
 429                         outline.n_contours=0;
 430                         FT_Stroker_Export (stroker, &outline);
 431                         FT_Outline_Get_BBox(&outline, &bbox);
 432                         FT_Outline_Translate(&outline, - bbox.xMin, - bbox.yMin);
 433                         FT_Outline_Translate(&((FT_OutlineGlyph) glyph_image)->outline,
 434                                         - bbox.xMin,
 435                                         - bbox.yMin + (int)(plugin->config.stroke_width*32));
 436 //                      printf("Stroke: Xmin: %ld, Xmax: %ld, Ymin: %ld, yMax: %ld\n"
 437 //                                      "Fill   Xmin: %ld, Xmax: %ld, Ymin: %ld, yMax: %ld\n",
 438 //                                      bbox.xMin,bbox.xMax, bbox.yMin, bbox.yMax,
 439 //                                      bbox_fill.xMin,bbox_fill.xMax, bbox_fill.yMin, bbox_fill.yMax);
 440
 441                         glyph->width = bm.width = ((bbox.xMax - bbox.xMin) >> 6)+1;
 442                         glyph->height = bm.rows = ((bbox.yMax - bbox.yMin) >> 6) +1;
 443                         glyph->pitch = bm.pitch = bm.width;
 444                         bm.pixel_mode = FT_PIXEL_MODE_GRAY;
 445                         bm.num_grays = 256;
 446                         glyph->left = (bbox.xMin + 31) >> 6;
 447                         glyph->top = (bbox.yMax + 31) >> 6;
 448                         glyph->right = (bbox.xMax + 31) >> 6;
 449                         glyph->bottom = (bbox.yMin + 31) >> 6;
 450                         glyph->freetype_index = gindex;
 451                         int real_advance = ((int)ceil((float)freetype_face->glyph->advance.x +
 452                                 plugin->config.stroke_width * 64) >> 6);
 453                         glyph->advance_x = glyph->width + glyph->left;
 454                         if (real_advance > glyph->advance_x)
 455                                 glyph->advance_x = real_advance;
 456 //printf("GlyphUnit::process_package 1 width=%d height=%d "
 457 // "pitch=%d left=%d top=%d advance_x=%d freetype_index=%d\n",
 458 // glyph->width, glyph->height, glyph->pitch, glyph->left,
 459 // glyph->top, glyph->advance_x, glyph->freetype_index);
 460
 461
 462 //printf("GlyphUnit::process_package 1\n");
 463                         glyph->data = new VFrame(glyph->width, glyph->height, BC_A8, glyph->pitch);
 464                         glyph->data->clear_frame();
 465                         glyph->data_stroke = new VFrame(glyph->width, glyph->height, BC_A8, glyph->pitch);
 466                         glyph->data_stroke->clear_frame();
 467 // for debugging        memset( glyph->data_stroke->get_data(), 60, glyph->pitch * glyph->height);
 468                         bm.buffer=glyph->data->get_data();
 469                         FT_Outline_Get_Bitmap( freetype_library,
 470                                 &((FT_OutlineGlyph) glyph_image)->outline,
 471                                 &bm);
 472                         bm.buffer=glyph->data_stroke->get_data();
 473                         FT_Outline_Get_Bitmap( freetype_library,
 474                         &outline,
 475                                 &bm);
 476                         FT_Outline_Done(freetype_library,&outline);
 477                         FT_Stroker_Done(stroker);
 478                         FT_Done_Glyph(glyph_image);
 479
 480 //printf("GlyphUnit::process_package 2\n");
 481                 }
 482         }
 483 }
 484
 485
 486
 487 GlyphEngine::GlyphEngine(TitleMain *plugin, int cpus)
 488  : LoadServer(cpus, cpus)
 489 {
 490         this->plugin = plugin;
 491 }
 492
 493 void GlyphEngine::init_packages()
 494 {
 495         int current_package = 0;
 496         for(int i = 0; i < plugin->glyphs.total; i++) {
 497                 if(!plugin->glyphs.values[i]->data) {
 498                         GlyphPackage *pkg = (GlyphPackage*)get_package(current_package++);
 499                         pkg->glyph = plugin->glyphs.values[i];
 500                 }
 501         }
 502 }
 503
 504 LoadClient* GlyphEngine::new_client()
 505 {
 506         return new GlyphUnit(plugin, this);
 507 }
 508
 509 LoadPackage* GlyphEngine::new_package()
 510 {
 511         return new GlyphPackage;
 512 }
 513
 514
 515
 516
 517
 518 // Copy a single character to the text mask
 519 TitlePackage::TitlePackage()
 520  : LoadPackage()
 521 {
 522         x = y = 0;
 523         char_code = 0;
 524 }
 525
 526
 527 TitleUnit::TitleUnit(TitleMain *plugin, TitleEngine *server)
 528  : LoadClient(server)
 529 {
 530         this->plugin = plugin;
 531         this->engine = server;
 532 }
 533
 534 void TitleUnit::draw_glyph(VFrame *output, VFrame *data, TitleGlyph *glyph, int x, int y)
 535 {
 536         int glyph_w = data->get_w(), glyph_h = data->get_h();
 537         int output_w = output->get_w(), output_h = output->get_h();
 538         unsigned char **in_rows = data->get_rows();
 539         unsigned char **out_rows = output->get_rows();
 540
 541         int baseline = plugin->get_char_height();
 542         if( engine->do_dropshadow ) {
 543                 x += plugin->config.dropshadow;
 544                 y += plugin->config.dropshadow;
 545         }
 546         else if( plugin->config.dropshadow < 0 ) {
 547                 x -= plugin->config.dropshadow;
 548                 y -= plugin->config.dropshadow;
 549         }
 550
 551         int x_in = 0, y_in = 0;
 552         int x_out = x + glyph->left;
 553         if( x_out < 0 ) { x_in = -x_out;  x_out = 0; }
 554         if( x_out+glyph_w > output_w ) glyph_w = output_w-x_out;
 555         if( x_in >= glyph_w || x_out >= output_w ) return;
 556         int y_out = y + baseline - glyph->top;
 557         if( y_out < 0 ) { y_in = -y_out;  y_out = 0; }
 558         if( y_out+glyph_h > output_h ) glyph_h = output_h-y_out;
 559         if( y_in >= glyph_h || y_out >= output_h ) return;
 560
 561         if(engine->do_dropshadow) {
 562                 while( y_in < glyph_h && y_out < output_h ) {
 563                         unsigned char *in_row = in_rows[y_in];
 564                         unsigned char *out_row = out_rows[y_out];
 565                         for( int xin=x_in,xout=x_out*4+3; xin<glyph_w; ++xin,xout+=4 ) {
 566                                 out_row[xout] = in_row[xin];
 567                         }
 568                         ++y_in;  ++y_out;
 569                 }
 570                 return;
 571         }
 572
 573         int r, g, b, a;
 574         plugin->get_color_components(&r, &g, &b, &a, 0);
 575         //int outline = plugin->config.outline_size;
 576         //if(outline) a = 0xff;
 577
 578         while( y_in < glyph_h && y_out < output_h ) {
 579                 unsigned char *in_row = in_rows[y_in];
 580                 unsigned char *out_row = out_rows[y_out];
 581                 for( int xin=x_in,xout=x_out*4+0; xin<glyph_w; ++xin,xout+=4 ) {
 582                         int in_a = in_row[xin], out_a = out_row[xout+3];
 583                         if( in_a + out_a == 0 ) continue;  // alpha blundering
 584                         int opacity = in_a * a, transp = out_a * (0xff - opacity/0xff);
 585                         out_row[xout+0] = (opacity * r + transp * out_row[xout+0]) / (0xff*0xff);
 586                         out_row[xout+1] = (opacity * g + transp * out_row[xout+1]) / (0xff*0xff);
 587                         out_row[xout+2] = (opacity * b + transp * out_row[xout+2]) / (0xff*0xff);
 588                         out_row[xout+3] = (opacity + transp) / 0xff;
 589                 }
 590                 ++y_in;  ++y_out;
 591         }
 592 }
 593
 594
 595 void TitleUnit::process_package(LoadPackage *package)
 596 {
 597         TitlePackage *pkg = (TitlePackage*)package;
 598
 599         if( pkg->char_code == 0 || pkg->char_code == '\n') return;
 600         TitleGlyph *glyph = plugin->get_glyph(pkg->char_code);
 601         if( !glyph ) return;
 602         draw_glyph(plugin->text_mask, glyph->data, glyph, pkg->x, pkg->y);
 603         if(plugin->config.stroke_width >= ZERO && (plugin->config.style & BC_FONT_OUTLINE))
 604                 draw_glyph(plugin->text_mask_stroke, glyph->data_stroke, glyph, pkg->x, pkg->y);
 605 }
 606
 607 TitleEngine::TitleEngine(TitleMain *plugin, int cpus)
 608  : LoadServer(cpus, cpus)
 609 {
 610         this->plugin = plugin;
 611 }
 612
 613 void TitleEngine::init_packages()
 614 {
 615         int current_package = 0;
 616         int dx = plugin->config.outline_size - plugin->extent.x1;
 617         int dy = plugin->config.outline_size - plugin->extent.y1;
 618         for(int i = plugin->visible_char1; i < plugin->visible_char2; i++) {
 619                 TitlePackage *pkg = (TitlePackage*)get_package(current_package++);
 620                 char_pos_t *pos = plugin->char_pos + i;
 621                 pkg->x = pos->x + dx;
 622                 pkg->y = pos->y + dy;
 623                 pkg->char_code = plugin->config.wtext[i];
 624 //printf("draw '%c' at %d,%d\n",(int)pkg->char_code, pkg->x, pkg->y);
 625         }
 626 }
 627
 628 LoadClient* TitleEngine::new_client()
 629 {
 630         return new TitleUnit(plugin, this);
 631 }
 632
 633 LoadPackage* TitleEngine::new_package()
 634 {
 635         return new TitlePackage;
 636 }
 637
 638 void TitleTranslateUnit::translation_array_f(transfer_table_f* &table,
 639         float out_x1,
 640         float out_x2,
 641         float in_x1,
 642         float in_x2,
 643         int in_total,
 644         int out_total,
 645         int &out_x1_int,
 646         int &out_x2_int)
 647 {
 648         int out_w_int;
 649         //float offset = out_x1 - in_x1;
 650
 651         out_x1_int = (int)out_x1;
 652         out_x2_int = MIN((int)ceil(out_x2), out_total);
 653         out_w_int = out_x2_int - out_x1_int;
 654
 655         table = new transfer_table_f[out_w_int];
 656         bzero(table, sizeof(transfer_table_f) * out_w_int);
 657
 658         float in_x = in_x1;
 659         for(int out_x = out_x1_int; out_x < out_x2_int; out_x++)
 660         {
 661                 transfer_table_f *entry = &table[out_x - out_x1_int];
 662
 663                 entry->in_x1 = (int)in_x;
 664                 entry->in_x2 = (int)in_x + 1;
 665
 666 // Get fraction of output pixel to fill
 667                 entry->output_fraction = 1;
 668
 669                 if(out_x1 > out_x)
 670                 {
 671                         entry->output_fraction -= out_x1 - out_x;
 672                 }
 673
 674                 if(out_x2 < out_x + 1)
 675                 {
 676                         entry->output_fraction = (out_x2 - out_x);
 677                 }
 678
 679 // Advance in_x until out_x_fraction is filled
 680                 float out_x_fraction = entry->output_fraction;
 681                 float in_x_fraction = floor(in_x + 1) - in_x;
 682
 683                 if(out_x_fraction <= in_x_fraction)
 684                 {
 685                         entry->in_fraction1 = out_x_fraction;
 686                         entry->in_fraction2 = 0.0;
 687                         in_x += out_x_fraction;
 688                 }
 689                 else
 690                 {
 691                         entry->in_fraction1 = in_x_fraction;
 692                         in_x += out_x_fraction;
 693                         entry->in_fraction2 = in_x - floor(in_x);
 694                 }
 695
 696 // Clip in_x and zero out fraction.  This doesn't work for YUV.
 697                 if(entry->in_x2 >= in_total)
 698                 {
 699                         entry->in_x2 = in_total - 1;
 700                         entry->in_fraction2 = 0.0;
 701                 }
 702
 703                 if(entry->in_x1 >= in_total)
 704                 {
 705                         entry->in_x1 = in_total - 1;
 706                         entry->in_fraction1 = 0.0;
 707                 }
 708         }
 709 }
 710
 711
 712
 713 // Copy a single character to the text mask
 714 TitleOutlinePackage::TitleOutlinePackage()
 715  : LoadPackage()
 716 {
 717 }
 718
 719
 720 TitleOutlineUnit::TitleOutlineUnit(TitleMain *plugin, TitleOutlineEngine *server)
 721  : LoadClient(server)
 722 {
 723         this->plugin = plugin;
 724         this->engine = server;
 725 }
 726
 727 void TitleOutlineUnit::process_package(LoadPackage *package)
 728 {
 729         TitleOutlinePackage *pkg = (TitleOutlinePackage*)package;
 730         int r, g, b, outline_a;
 731         plugin->get_color_components(&r, &g, &b, &outline_a, 1);
 732         unsigned char **outline_rows = plugin->outline_mask->get_rows();
 733         unsigned char **text_rows = plugin->text_mask->get_rows();
 734         int mask_w1 = plugin->text_mask->get_w()-1;
 735         int mask_h1 = plugin->text_mask->get_h()-1;
 736         int ofs = plugin->config.outline_size;
 737
 738         if(engine->pass == 0) {
 739 // get max alpha under outline size macropixel
 740                 for(int y = pkg->y1; y < pkg->y2; y++) {
 741                         unsigned char *out_row = outline_rows[y];
 742                         int y1 = y - ofs, y2 = y + ofs;
 743                         CLAMP(y1, 0, mask_h1);  CLAMP(y2, 0, mask_h1);
 744                         for(int x = 0; x < plugin->text_mask->get_w(); x++) {
 745                                 int x1 = x - ofs, x2 = x + ofs;
 746                                 CLAMP(x1, 0, mask_w1);  CLAMP(x2, 0, mask_w1);
 747
 748                                 int max_a = 0;
 749                                 for(int yy = y1; yy <= y2; yy++) {
 750                                         unsigned char *text_row = text_rows[yy];
 751                                         for(int xx = x1; xx <= x2; ++xx) {
 752                                                 unsigned char *pixel = text_row + xx*4;
 753                                                 if(pixel[3] > max_a) max_a = pixel[3];
 754                                         }
 755                                 }
 756
 757                                 unsigned char *out = out_row + x*4;
 758                                 out[0] = r;  out[1] = g;  out[2] = b;
 759                                 out[3] = (max_a * outline_a) / 0xff;
 760                         }
 761                 }
 762                 return;
 763         }
 764         else {
 765 // Overlay text mask on top of outline mask
 766                 int ofs = BC_CModels::is_yuv(plugin->output->get_color_model()) ? 0x80 : 0;
 767                 for(int y = pkg->y1; y < pkg->y2; y++) {
 768                         unsigned char *outline_row = outline_rows[y];
 769                         unsigned char *text_row = text_rows[y];
 770                         for(int x = 0; x < plugin->text_mask->get_w(); x++) {
 771                                 unsigned char *out = text_row + x * 4;
 772                                 unsigned char *inp = outline_row + x * 4;
 773                                 int out_a = out[3], in_a = inp[3];
 774                                 int transparency = in_a * (0xff - out_a) / 0xff;
 775                                 out[0] = (out[0] * out_a + inp[0] * transparency) / 0xff;
 776                                 out[1] = ((out[1]-ofs) * out_a + (inp[1]-ofs) * transparency) / 0xff + ofs;
 777                                 out[2] = ((out[2]-ofs) * out_a + (inp[2]-ofs) * transparency) / 0xff + ofs;
 778                                 out[3] = in_a + out_a - in_a*out_a / 0xff;
 779                         }
 780                 }
 781         }
 782 }
 783
 784 TitleOutlineEngine::TitleOutlineEngine(TitleMain *plugin, int cpus)
 785  : LoadServer(cpus, cpus)
 786 {
 787         this->plugin = plugin;
 788 }
 789
 790 void TitleOutlineEngine::init_packages()
 791 {
 792         int mask_h = plugin->text_mask->get_h();
 793         if( !mask_h ) return;
 794         int py1 = 0, py2 = 0;
 795         int pkgs = get_total_packages();
 796         for( int i=0; i<pkgs; py1=py2 ) {
 797                 TitleOutlinePackage *pkg = (TitleOutlinePackage*)get_package(i);
 798                 py2 = (++i * mask_h)/ pkgs;
 799                 pkg->y1 = py1;  pkg->y2 = py2;
 800         }
 801 }
 802
 803 void TitleOutlineEngine::do_outline()
 804 {
 805         pass = 0;  process_packages();
 806         pass = 1;  process_packages();
 807 }
 808
 809 LoadClient* TitleOutlineEngine::new_client()
 810 {
 811         return new TitleOutlineUnit(plugin, this);
 812 }
 813
 814 LoadPackage* TitleOutlineEngine::new_package()
 815 {
 816         return new TitleOutlinePackage;
 817 }
 818
 819
 820
 821 TitleTranslatePackage::TitleTranslatePackage()
 822  : LoadPackage()
 823 {
 824         y1 = y2 = 0;
 825 }
 826
 827
 828 TitleTranslateUnit::TitleTranslateUnit(TitleMain *plugin, TitleTranslate *server)
 829  : LoadClient(server)
 830 {
 831         this->plugin = plugin;
 832 }
 833
 834 void TitleTranslate::run_packages()
 835 {
 836         output_w = plugin->output->get_w();
 837         output_h = plugin->output->get_h();
 838
 839         float x1 = plugin->text_x1 + plugin->extent.x1;
 840         float x2 = plugin->text_x1 + plugin->extent.x2;
 841         if (x2 <= 0 || x1 >= x2 || x1 >= output_w) return;
 842
 843         float y1 = plugin->text_y1 + plugin->extent.y1;
 844         float y2 = plugin->text_y1 + plugin->extent.y2;
 845         if (y2 <= 0 || y1 >= y2 || y1 >= output_h) return;
 846
 847         process_packages();
 848 }
 849
 850
 851
 852 #define TRANSLATE(type, max, components, ofs) \
 853 { \
 854         unsigned char **in_rows = plugin->text_mask->get_rows(); \
 855         type **out_rows = (type**)plugin->output->get_rows(); \
 856  \
 857         for(int i = pkg->y1; i < pkg->y2; i++) \
 858         { \
 859                 if(i + server->out_y1_int >= 0 && \
 860                         i + server->out_y1_int < server->output_h) \
 861                 { \
 862                         int in_y1, in_y2; \
 863                         float y_fraction1, y_fraction2; \
 864                         in_y1 = server->y_table[i].in_x1; \
 865                         in_y2 = server->y_table[i].in_x2; \
 866                         y_fraction1 = server->y_table[i].in_fraction1; \
 867                         y_fraction2 = server->y_table[i].in_fraction2; \
 868                         unsigned char *in_row1 = in_rows[in_y1]; \
 869                         unsigned char *in_row2 = in_rows[in_y2]; \
 870                         type *out_row = out_rows[i + server->out_y1_int]; \
 871  \
 872                         for(int j = server->out_x1_int; j < server->out_x2_int; j++) \
 873                         { \
 874                                 if(j >= 0 && j < server->output_w) \
 875                                 { \
 876                                         int in_x1; \
 877                                         int in_x2; \
 878                                         float x_fraction1; \
 879                                         float x_fraction2; \
 880                                         in_x1 =  \
 881                                                 server->x_table[j - server->out_x1_int].in_x1; \
 882                                         in_x2 =  \
 883                                                 server->x_table[j - server->out_x1_int].in_x2; \
 884                                         x_fraction1 =  \
 885                                                 server->x_table[j - server->out_x1_int].in_fraction1; \
 886                                         x_fraction2 =  \
 887                                                 server->x_table[j - server->out_x1_int].in_fraction2; \
 888  \
 889                                         float fraction1 = x_fraction1 * y_fraction1 / (256.f-max); \
 890                                         float fraction2 = x_fraction2 * y_fraction1 / (256.f-max); \
 891                                         float fraction3 = x_fraction1 * y_fraction2 / (256.f-max); \
 892                                         float fraction4 = x_fraction2 * y_fraction2 / (256.f-max); \
 893                                         type input_r = (type)(in_row1[in_x1 * 4 + 0] * fraction1 +  \
 894                                                                 in_row1[in_x2 * 4 + 0] * fraction2 +  \
 895                                                                 in_row2[in_x1 * 4 + 0] * fraction3 +  \
 896                                                                 in_row2[in_x2 * 4 + 0] * fraction4); \
 897                                         type input_g = (type)(in_row1[in_x1 * 4 + 1] * fraction1 +  \
 898                                                                 in_row1[in_x2 * 4 + 1] * fraction2 +  \
 899                                                                 in_row2[in_x1 * 4 + 1] * fraction3 +  \
 900                                                                 in_row2[in_x2 * 4 + 1] * fraction4); \
 901                                         type input_b = (type)(in_row1[in_x1 * 4 + 2] * fraction1 +  \
 902                                                                 in_row1[in_x2 * 4 + 2] * fraction2 +  \
 903                                                                 in_row2[in_x1 * 4 + 2] * fraction3 +  \
 904                                                                 in_row2[in_x2 * 4 + 2] * fraction4); \
 905                                         type input_a = (type)(in_row1[in_x1 * 4 + 3] * fraction1 +  \
 906                                                                 in_row1[in_x2 * 4 + 3] * fraction2 +  \
 907                                                                 in_row2[in_x1 * 4 + 3] * fraction3 +  \
 908                                                                 in_row2[in_x2 * 4 + 3] * fraction4); \
 909 /* Plugin alpha is actually 0 - 0x100 */ \
 910                                         input_a = input_a * plugin->alpha / 0x100; \
 911                                         type transparency; \
 912  \
 913  \
 914                                         if(components == 4) \
 915                                         { \
 916                                                 transparency = out_row[j * components + 3] * (max - input_a) / max; \
 917                                                 out_row[j * components + 0] =  \
 918                                                         (input_r * input_a + out_row[j * components + 0] * transparency) / max; \
 919                                                 out_row[j * components + 1] =  \
 920                                                         ((input_g-ofs) * input_a + (out_row[j * components + 1]-ofs) * transparency) / max + ofs; \
 921                                                 out_row[j * components + 2] =  \
 922                                                         ((input_b-ofs) * input_a + (out_row[j * components + 2]-ofs) * transparency) / max + ofs; \
 923                                                 out_row[j * components + 3] =  \
 924                                                         MAX(input_a, out_row[j * components + 3]); \
 925                                         } \
 926                                         else \
 927                                         { \
 928                                                 transparency = max - input_a; \
 929                                                 out_row[j * components + 0] =  \
 930                                                         (input_r * input_a + out_row[j * components + 0] * transparency) / max; \
 931                                                 out_row[j * components + 1] =  \
 932                                                         ((input_g-ofs) * input_a + (out_row[j * components + 1]-ofs) * transparency) / max + ofs; \
 933                                                 out_row[j * components + 2] =  \
 934                                                         ((input_b-ofs) * input_a + (out_row[j * components + 2]-ofs) * transparency) / max + ofs; \
 935                                         } \
 936                                 } \
 937                         } \
 938                 } \
 939         } \
 940 }
 941
 942 #define TRANSLATEA(type, max, components, r, g, b) \
 943 { \
 944         unsigned char **in_rows = plugin->text_mask->get_rows(); \
 945         type **out_rows = (type**)plugin->output->get_rows(); \
 946  \
 947         for(int i = pkg->y1; i < pkg->y2; i++) \
 948         { \
 949                 if(i + server->out_y1_int >= 0 && \
 950                         i + server->out_y1_int < server->output_h) \
 951                 { \
 952                         unsigned char *in_row = in_rows[i]; \
 953                         type *out_row = out_rows[i + server->out_y1_int]; \
 954  \
 955                         for(int j = server->out_x1; j < server->out_x2_int; j++) \
 956                         { \
 957                                 if(j  >= 0 && \
 958                                         j < server->output_w) \
 959                                 { \
 960                                         int input = (int)(in_row[j - server->out_x1]);  \
 961  \
 962                                         input *= plugin->alpha; \
 963 /* Alpha is 0 - 256 */ \
 964                                         input >>= 8; \
 965  \
 966                                         int anti_input = 0xff - input; \
 967                                         if(components == 4) \
 968                                         { \
 969                                                 out_row[j * components + 0] =  \
 970                                                         (r * input + out_row[j * components + 0] * anti_input) / 0xff; \
 971                                                 out_row[j * components + 1] =  \
 972                                                         (g * input + out_row[j * components + 1] * anti_input) / 0xff; \
 973                                                 out_row[j * components + 2] =  \
 974                                                         (b * input + out_row[j * components + 2] * anti_input) / 0xff; \
 975                                                 if(max == 0xffff) \
 976                                                         out_row[j * components + 3] =  \
 977                                                                 MAX((input << 8) | input, out_row[j * components + 3]); \
 978                                                 else \
 979                                                         out_row[j * components + 3] =  \
 980                                                                 MAX(input, out_row[j * components + 3]); \
 981                                         } \
 982                                         else \
 983                                         { \
 984                                                 out_row[j * components + 0] =  \
 985                                                         (r * input + out_row[j * components + 0] * anti_input) / 0xff; \
 986                                                 out_row[j * components + 1] =  \
 987                                                         (g * input + out_row[j * components + 1] * anti_input) / 0xff; \
 988                                                 out_row[j * components + 2] =  \
 989                                                         (b * input + out_row[j * components + 2] * anti_input) / 0xff; \
 990                                         } \
 991                                 } \
 992                         } \
 993                 } \
 994         } \
 995 }
 996
 997 void TitleTranslateUnit::process_package(LoadPackage *package)
 998 {
 999         TitleTranslatePackage *pkg = (TitleTranslatePackage*)package;
1000         TitleTranslate *server = (TitleTranslate*)this->server;
1001
1002         switch(plugin->output->get_color_model()) {
1003         case BC_RGB888:     TRANSLATE(unsigned char, 0xff, 3, 0);    break;
1004         case BC_RGB_FLOAT:  TRANSLATE(float, 1.0, 3, 0);             break;
1005         case BC_YUV888:     TRANSLATE(unsigned char, 0xff, 3, 0x80); break;
1006         case BC_RGBA_FLOAT: TRANSLATE(float, 1.0, 4, 0);             break;
1007         case BC_RGBA8888:   TRANSLATE(unsigned char, 0xff, 4, 0);    break;
1008         case BC_YUVA8888:   TRANSLATE(unsigned char, 0xff, 4, 0x80); break;
1009         }
1010 //printf("TitleTranslateUnit::process_package 5\n");
1011 }
1012
1013
1014
1015
1016 TitleTranslate::TitleTranslate(TitleMain *plugin, int cpus)
1017  : LoadServer(cpus, cpus)
1018 {
1019         this->plugin = plugin;
1020         x_table = 0;
1021         y_table = 0;
1022         out_x1 = out_x2 = 0;
1023         out_y1 = out_y2 = 0;
1024         out_x1_int = out_x2_int = 0;
1025         out_y1_int = out_y2_int = 0;
1026         output_w = output_h = 0;
1027 }
1028
1029 TitleTranslate::~TitleTranslate()
1030 {
1031         delete [] x_table;
1032         delete [] y_table;
1033 }
1034
1035 void TitleTranslate::init_packages()
1036 {
1037 // Generate scaling tables
1038         delete [] x_table;  x_table = 0;
1039         delete [] y_table;  y_table = 0;
1040
1041         output_w = plugin->output->get_w();
1042         output_h = plugin->output->get_h();
1043
1044         float x1 = plugin->text_x1 + plugin->extent.x1;
1045         float x2 = plugin->text_x1 + plugin->extent.x2;
1046         TitleTranslateUnit::translation_array_f(x_table, x1, x2, 0,
1047                 plugin->mask_w, plugin->mask_w,
1048                 output_w, out_x1_int, out_x2_int);
1049
1050         float y1 = plugin->text_y1 + plugin->extent.y1;
1051         float y2 = plugin->text_y1 + plugin->extent.y2;
1052         TitleTranslateUnit::translation_array_f(y_table, y1, y2, 0,
1053                 plugin->mask_h, plugin->mask_h,
1054                 output_h, out_y1_int, out_y2_int);
1055
1056 //printf("TitleTranslate::init_packages 1\n");
1057         out_x1 = out_x1_int;  out_x2 = out_x2_int;
1058         out_y1 = out_y1_int;  out_y2 = out_y2_int;
1059
1060         int out_h = out_y2 - out_y1;
1061         int py1 = 0, py2 = 0;
1062         int pkgs = get_total_packages();
1063         for( int i=0; i<pkgs; py1=py2 ) {
1064                 TitleTranslatePackage *pkg = (TitleTranslatePackage*)get_package(i);
1065                 py2 = (++i*out_h) / pkgs;
1066                 pkg->y1 = py1;  pkg->y2 = py2;
1067         }
1068 //printf("TitleTranslate::init_packages 2\n");
1069 }
1070
1071 LoadClient* TitleTranslate::new_client()
1072 {
1073         return new TitleTranslateUnit(plugin, this);
1074 }
1075
1076 LoadPackage* TitleTranslate::new_package()
1077 {
1078         return new TitleTranslatePackage;
1079 }
1080
1081
1082
1083 TitleMain::TitleMain(PluginServer *server)
1084  : PluginVClient(server)
1085 {
1086         text_mask = 0;
1087         outline_mask = 0;
1088         text_mask_stroke = 0;
1089         glyph_engine = 0;
1090         title_engine = 0;
1091         freetype_face = 0;
1092         freetype_library = 0;
1093         char_pos = 0;
1094         row_geom = 0;
1095         row_geom_size = 0;
1096         translate = 0;
1097         outline_engine = 0;
1098         visible_row1 = 0;       visible_row2 = 0;
1099         visible_char1 = 0;      visible_char2 = 0;
1100         text_y1 = text_y2 = text_x1 = 0;
1101         alpha = 0x100;
1102         text_rows = 0;
1103         text_w = 0; text_h = 0;
1104         input = 0;  output = 0;
1105         cpus = PluginClient::smp + 1;
1106         if( cpus > 8 ) cpus = 8;
1107         need_reconfigure = 1;
1108 }
1109
1110 TitleMain::~TitleMain()
1111 {
1112         delete text_mask;
1113         delete outline_mask;
1114         delete text_mask_stroke;
1115         delete [] char_pos;
1116         delete [] row_geom;
1117         clear_glyphs();
1118         delete glyph_engine;
1119         delete title_engine;
1120         if( freetype_face )
1121                 FT_Done_Face(freetype_face);
1122         if( freetype_library )
1123                 FT_Done_FreeType(freetype_library);
1124         delete translate;
1125         delete outline_engine;
1126 }
1127
1128 const char* TitleMain::plugin_title() { return _("Title"); }
1129 int TitleMain::is_realtime() { return 1; }
1130 int TitleMain::is_synthesis() { return 1; }
1131
1132 NEW_WINDOW_MACRO(TitleMain, TitleWindow);
1133
1134
1135 void TitleMain::build_previews(TitleWindow *gui)
1136 {
1137         ArrayList<BC_FontEntry*>*fonts = gui->get_resources()->fontlist;
1138
1139         for(int font_number = 0; font_number < fonts->size(); font_number++)
1140         {
1141                 BC_FontEntry *font_entry = fonts->get(font_number);
1142 // already have examples
1143                 if(font_entry->image) return;
1144         }
1145
1146 // create example bitmaps
1147         FT_Library freetype_library = 0;        // Freetype library
1148         FT_Face freetype_face = 0;
1149         const char *test_string = "Aa";
1150         char new_path[BCTEXTLEN];
1151         int text_height = gui->get_text_height(LARGEFONT);
1152         int text_color = BC_WindowBase::get_resources()->default_text_color;
1153         int r = (text_color >> 16) & 0xff;
1154         int g = (text_color >> 8) & 0xff;
1155         int b = text_color & 0xff;
1156 // dimensions for each line
1157         int height[fonts->size()];
1158         int ascent[fonts->size()];
1159
1160 // pass 1 gets the extents for all the fonts
1161 // pass 2 draws the image
1162         int total_w = 0;
1163         int total_h = 0;
1164         for(int pass = 0; pass < 2; pass++)
1165         {
1166 //printf("TitleMain::build_previews %d %d %d\n",
1167 //__LINE__,
1168 //text_height,
1169 //total_h);
1170                 for(int font_number = 0; font_number < fonts->size(); font_number++)
1171                 {
1172                         BC_FontEntry *font_entry = fonts->get(font_number);
1173
1174 // test if font of same name has been processed
1175                         int skip = 0;
1176                         for(int i = 0; i < font_number; i++) {
1177                                 if(!strcasecmp(fonts->get(i)->displayname, font_entry->displayname)) {
1178                                         if(pass == 1) {
1179                                                 font_entry->image = fonts->get(i)->image;
1180                                         }
1181                                         skip = 1;
1182                                         break;
1183                                 }
1184                         }
1185
1186                         if(skip) continue;
1187
1188                         int current_x = 0;
1189                         int current_w = 0;
1190                         int current_ascent = 0;
1191                         int current_h = 0;
1192                         if(pass == 1) {
1193                                 font_entry->image = new VFrame;
1194                                 font_entry->image->set_use_shm(0);
1195                                 font_entry->image->reallocate(0, -1, 0, 0, 0,
1196                                         total_w, total_h, BC_RGBA8888, -1);
1197                                 font_entry->image->clear_frame();
1198                         }
1199
1200                         current_x = 0;
1201                         current_w = 0;
1202                         int len = strlen(test_string);
1203                         for(int j = 0; j < len; j++)
1204                         {
1205                                 FT_ULong c = test_string[j];
1206 // memory leaks here are fatal
1207 //                              check_char_code_path(freetype_library,
1208 //                                      font_entry->path,
1209 //                                      c,
1210 //                                      (char *)new_path);
1211                                 strcpy(new_path, font_entry->path);
1212                                 if( !load_freetype_face(freetype_library,
1213                                         freetype_face, new_path)) {
1214                                         FT_Set_Pixel_Sizes(freetype_face, text_height, 0);
1215
1216                                         if(!FT_Load_Char(freetype_face, c, FT_LOAD_RENDER)) {
1217                                                 if(pass == 0) {
1218                                                         current_w = current_x + freetype_face->glyph->bitmap.width;
1219                                                         if((int)freetype_face->glyph->bitmap_top > current_ascent)
1220                                                                 current_ascent = freetype_face->glyph->bitmap_top;
1221                                                         if((int)freetype_face->glyph->bitmap.rows > total_h)
1222                                                                 total_h = freetype_face->glyph->bitmap.rows;
1223                                                         if((int)freetype_face->glyph->bitmap.rows > current_h)
1224                                                                 current_h = freetype_face->glyph->bitmap.rows;
1225                                                 }
1226                                                 else {
1227 // copy 1 row at a time
1228 // center vertically
1229                                                         int out_y = (total_h - height[font_number]) / 2 +
1230                                                                 ascent[font_number] - freetype_face->glyph->bitmap_top;
1231                                                         for(int in_y = 0;
1232                                                                 in_y < (int)freetype_face->glyph->bitmap.rows &&
1233                                                                         out_y < total_h;
1234                                                                 in_y++, out_y++) {
1235                                                                 unsigned char *out_row = font_entry->image->get_rows()[out_y] +
1236                                                                         current_x * 4;
1237                                                                 unsigned char *in_row = freetype_face->glyph->bitmap.buffer +
1238                                                                         freetype_face->glyph->bitmap.pitch * in_y;
1239
1240                                                                 for(int out_x = 0; out_x < (int)freetype_face->glyph->bitmap.width &&
1241                                                                         out_x < total_w;
1242                                                                         out_x++) {
1243                                                                         *out_row = (*in_row * r +
1244                                                                                 (0xff - *in_row) * *out_row) / 0xff; ++out_row;
1245                                                                         *out_row = (*in_row * g +
1246                                                                                 (0xff - *in_row) * *out_row) / 0xff; ++out_row;
1247                                                                         *out_row = (*in_row * b +
1248                                                                                 (0xff - *in_row) * *out_row) / 0xff; ++out_row;
1249                                                                         *out_row = MAX(*in_row, *out_row);  ++out_row;
1250                                                                         in_row++;
1251                                                                 }
1252                                                         }
1253                                                 }
1254
1255
1256                                                 current_x += freetype_face->glyph->advance.x >> 6;
1257                                         }
1258                                 }
1259                         }
1260
1261                         height[font_number] = current_h;
1262                         ascent[font_number] = current_ascent;
1263                         if(pass == 0 && current_w > total_w) total_w = current_w;
1264
1265                 }
1266         }
1267
1268         if(freetype_library) FT_Done_FreeType(freetype_library);
1269 }
1270
1271
1272
1273 //This checks if char_code is on the selected font, else it changes font to the first compatible //Akirad
1274 int TitleMain::check_char_code_path(FT_Library &freetype_library,
1275         char *path_old,
1276         FT_ULong &char_code,
1277         char *path_new)
1278 {
1279         FT_Face temp_freetype_face;
1280         FcPattern *pat;
1281         FcFontSet *fs;
1282         FcObjectSet *os;
1283         FcChar8 *file, *format;
1284         FcConfig *config;
1285         int i;
1286
1287         FcInit();
1288         config = FcConfigGetCurrent();
1289         FcConfigSetRescanInterval(config, 0);
1290
1291         pat = FcPatternCreate();
1292         os = FcObjectSetBuild ( FC_FILE, FC_FONTFORMAT, (char *) 0);
1293         fs = FcFontList(config, pat, os);
1294         FcPattern *font;
1295         int notfindit = 1;
1296         char tmpstring[BCTEXTLEN];
1297         int limit_to_truetype = 0; //if you want to limit search to truetype put 1
1298         if(!freetype_library) FT_Init_FreeType(&freetype_library);
1299         if(!FT_New_Face(freetype_library,
1300                                         path_old,
1301                                         0,
1302                                         &temp_freetype_face))
1303         {
1304                 FT_Set_Pixel_Sizes(temp_freetype_face, 128, 0);
1305                 int gindex = FT_Get_Char_Index(temp_freetype_face, char_code);
1306                 if( gindex != 0 && char_code == 10 )
1307                 {
1308                         strcpy(path_new, path_old);
1309                         notfindit = 0;
1310                 }
1311         }
1312
1313         if(notfindit)
1314         {
1315                 for (i=0; fs && i < fs->nfont; i++)
1316                 {
1317                         font = fs->fonts[i];
1318                         FcPatternGetString(font, FC_FONTFORMAT, 0, &format);
1319                         if((!strcmp((char *)format, "TrueType")) || limit_to_truetype)
1320                         {
1321                                 if(FcPatternGetString(font, FC_FILE, 0, &file) == FcResultMatch)
1322                                 {
1323
1324                                         sprintf(tmpstring, "%s", file);
1325                                         if(!FT_New_Face(freetype_library,
1326                                                                 tmpstring,
1327                                                                 0,
1328                                                                 &temp_freetype_face))
1329                                         {
1330                                                 FT_Set_Pixel_Sizes(temp_freetype_face, 128, 0);
1331                                                 int gindex = FT_Get_Char_Index(temp_freetype_face, char_code);
1332                                                 if( gindex != 0 && char_code == 10 )
1333                                                 {
1334                                                         sprintf(path_new, "%s", tmpstring);
1335                                                         notfindit = 0;
1336                                                         goto done;
1337
1338                                                 }
1339                                         }
1340                                 }
1341                         }
1342                 }
1343         }
1344
1345 done:
1346         if(fs) FcFontSetDestroy(fs);
1347         if(temp_freetype_face) FT_Done_Face(temp_freetype_face);
1348         temp_freetype_face = 0;
1349
1350         if(notfindit)
1351         {
1352                 strcpy(path_new, path_old);
1353                 return 1;
1354         }
1355
1356         return 0;
1357 }
1358
1359
1360
1361
1362 int TitleMain::load_freetype_face(FT_Library &freetype_library,
1363         FT_Face &freetype_face,
1364         const char *path)
1365 {
1366 //printf("TitleMain::load_freetype_face 1\n");
1367         if(!freetype_library)
1368                 FT_Init_FreeType(&freetype_library);
1369         if(freetype_face)
1370                 FT_Done_Face(freetype_face);
1371         freetype_face = 0;
1372 //printf("TitleMain::load_freetype_face 2\n");
1373
1374 // Use freetype's internal function for loading font
1375         if(FT_New_Face(freetype_library, path, 0, &freetype_face)) {
1376                 fprintf(stderr, _("TitleMain::load_freetype_face %s failed.\n"), path);
1377                 freetype_face = 0;
1378                 freetype_library = 0;
1379                 return 1;
1380         }
1381         return 0;
1382 }
1383
1384 BC_FontEntry* TitleMain::get_font()
1385 {
1386         int style = 0;
1387         int mask, pref;
1388
1389         style |= (config.style & BC_FONT_ITALIC) ?
1390                 FL_SLANT_ITALIC | FL_SLANT_OBLIQUE : FL_SLANT_ROMAN;
1391         style |= (config.style & BC_FONT_BOLD) ?
1392                 FL_WEIGHT_BOLD | FL_WEIGHT_DEMIBOLD |
1393                 FL_WEIGHT_EXTRABOLD| FL_WEIGHT_BLACK | FL_WEIGHT_EXTRABLACK :
1394                 FL_WEIGHT_BOOK | FL_WEIGHT_NORMAL | FL_WEIGHT_MEDIUM |
1395                 FL_WEIGHT_LIGHT | FL_WEIGHT_EXTRALIGHT | FL_WEIGHT_THIN;
1396
1397         pref = style & (FL_SLANT_ITALIC | FL_WEIGHT_BOLD | FL_WEIGHT_NORMAL);
1398
1399         mask = FL_WEIGHT_MASK | FL_SLANT_MASK;
1400
1401         BC_Resources *resources =  BC_WindowBase::get_resources();
1402         return resources->find_fontentry(config.font, style, mask, pref);
1403 }
1404
1405 int TitleMain::get_char_height()
1406 {
1407 // this is baseline to the baseline distance
1408         int result = config.size;
1409         if((config.style & BC_FONT_OUTLINE)) result += (int)ceil(config.stroke_width * 2);
1410         return result;
1411 }
1412
1413 TitleGlyph *TitleMain::get_glyph(FT_ULong char_code)
1414 {
1415         for(int i = 0; i < glyphs.size(); i++) {
1416                 if(glyphs.get(i)->char_code == char_code)
1417                         return glyphs.get(i);
1418         }
1419         return 0;
1420 }
1421
1422 int TitleMain::get_char_width(FT_ULong char_code)
1423 {
1424         if(char_code == '\n') return 0;
1425         TitleGlyph *glyph = get_glyph(char_code);
1426         return !glyph ? 0 : glyph->width;
1427 }
1428
1429 int TitleMain::get_char_advance(FT_ULong current, FT_ULong next)
1430 {
1431         FT_Vector kerning;
1432
1433         if(current == '\n') return 0;
1434         TitleGlyph *current_glyph = get_glyph(current);
1435         int result = !current_glyph ? 0 : current_glyph->advance_x;
1436         TitleGlyph *next_glyph = !next ? 0 : get_glyph(next);
1437         if(next_glyph)
1438                 FT_Get_Kerning(freetype_face,
1439                                 current_glyph->freetype_index,
1440                                 next_glyph->freetype_index,
1441                                 ft_kerning_default,
1442                                 &kerning);
1443         else
1444                 kerning.x = 0;
1445         return result + (kerning.x >> 6);
1446 }
1447
1448 void TitleMain::load_glyphs()
1449 {
1450 // Build table of all glyphs needed
1451         int total_packages = 0;
1452
1453         for(int i = 0; i < config.wlen; i++)
1454         {
1455                 int exists = 0;
1456                 FT_ULong char_code = config.wtext[i];
1457
1458                 for(int j = 0; j < glyphs.total; j++) {
1459                         if(glyphs.values[j]->char_code == char_code) {
1460                                 exists = 1;
1461                                 break;
1462                         }
1463                 }
1464
1465                 if(!exists && char_code != 0) {
1466                         total_packages++;
1467                         TitleGlyph *glyph = new TitleGlyph;
1468                         glyphs.append(glyph);
1469                         glyph->char_code = char_code;
1470                 }
1471         }
1472
1473         if(!glyph_engine)
1474                 glyph_engine = new GlyphEngine(this, cpus);
1475
1476         glyph_engine->set_package_count(total_packages);
1477         glyph_engine->process_packages();
1478 }
1479
1480
1481 void TitleMain::get_total_extents()
1482 {
1483 // Determine extents of total text
1484         int wlen = config.wlen;
1485         char_pos = new char_pos_t[wlen+1];
1486
1487         int pitch = config.line_pitch;
1488         int font_h = get_char_height();
1489         int row = 0;
1490         int row_w = 0, row_h = 0;
1491         int max_char_w = 0, max_char_h = 0;
1492         text_h = text_w = 0;
1493
1494         // unjustified positions, initial bbox
1495         for(int i = 0; i < wlen; i++) {
1496                 char_pos[i].x = row_w;
1497                 char_pos[i].y = text_h;
1498                 char_pos[i].row = row;
1499                 wchar_t wchar = config.wtext[i];
1500                 if( wchar == '\n' ) {
1501                         text_h += pitch ? pitch : row_h > font_h ? row_h : font_h;
1502                         if(row_w > text_w) text_w = row_w;
1503                         row_w = row_h = 0;  ++row;
1504                         continue;
1505                 }
1506                 TitleGlyph *glyph = get_glyph(wchar);
1507                 int char_w = i+1>=wlen ? glyph->width :
1508                         get_char_advance(wchar, config.wtext[i+1]);
1509                 char_pos[i].w = char_w;
1510                 row_w += char_w;
1511                 if( char_w > max_char_w ) max_char_w = char_w;
1512                 int char_h = glyph->top - glyph->bottom;
1513                 if( char_h > max_char_h ) max_char_h = char_h;
1514                 if( char_h > row_h ) row_h = char_h;
1515 //printf("charcode '%c'  %d,%d  glyph bbox %d,%d %d,%d\n",
1516 //  (int)wchar, char_pos[i].x, char_pos[i].y,
1517 //  glyph->left, glyph->top, glyph->right, glyph->bottom);
1518         }
1519         if( wlen > 0 && config.wtext[wlen-1] != '\n' ) {
1520                 text_h += pitch ? pitch : row_h > font_h ? row_h : font_h;
1521                 if(row_w > text_w) text_w = row_w;
1522                 ++row;
1523         }
1524         char_pos[wlen].x = row_w;
1525         char_pos[wlen].y = text_h;
1526         char_pos[wlen].row = row;
1527         char_pos[wlen].w = 0;
1528         text_rows = row;
1529
1530         // justify positions
1531         int row_start = 0, pos = 0;
1532         switch(config.hjustification) {
1533         case JUSTIFY_MID:
1534                 while( row_start < wlen ) {
1535                         while( pos<wlen && config.wtext[pos]!='\n' ) ++pos;
1536                         int ofs = (text_w - char_pos[pos].x) / 2;
1537 //printf("justify_mid ofs=%d\n", ofs);
1538                         while( row_start < pos )
1539                                 char_pos[row_start++].x += ofs;
1540                         ++pos;
1541                 }
1542                 break;
1543         case JUSTIFY_RIGHT:
1544                 while( row_start < wlen ) {
1545                         while( pos<wlen && config.wtext[pos]!='\n' ) ++pos;
1546                         int ofs = text_w - char_pos[pos].x;
1547 //printf("justify_right ofs=%d\n", ofs);
1548                         while( row_start < pos )
1549                                 char_pos[row_start++].x += ofs;
1550                         ++pos;
1551                 }
1552                 break;
1553         case JUSTIFY_LEFT:
1554         default:
1555                 break;
1556         }
1557
1558         if( row_geom_size < text_rows+1 ) {
1559                 delete [] row_geom;   row_geom = 0;
1560         }
1561         if (!row_geom) {
1562                 row_geom_size = text_rows+1;
1563                 row_geom = new RowGeom[row_geom_size];
1564         }
1565
1566         // Determine row extents
1567         struct RowGeom *geom = &row_geom[0];
1568         TitleGlyph *glyph = 0;
1569         geom->x0 = geom->y0 = 0;
1570         geom->x1 = geom->y1 = 0;
1571         geom->x2 = geom->y2 = 0;
1572
1573         // x0,y0 row origin in without kern
1574         // x1,y1 - x2,y2 left baseline relative bbox with kerns
1575         for(int i = 0; i < wlen; i++) {
1576                 int x = char_pos[i].x;
1577                 int y = char_pos[i].y;
1578                 wchar_t wchar = config.wtext[i];
1579                 if( wchar == '\n' ) {
1580                         glyph = 0;  ++geom;
1581                         geom->x0 = geom->y0 = 0;
1582                         geom->x1 = geom->y1 = 0;
1583                         geom->x2 = geom->y2 = 0;
1584                         continue;
1585                 }
1586                 TitleGlyph *gp = get_glyph(wchar);
1587                 if( !gp ) continue;
1588                 if( !glyph ) {
1589                         geom->x0 = x;          geom->y0 = y;
1590                         int dx = x-geom->x0, dy = y-geom->y0 + config.size;
1591                         geom->x1 = dx + gp->left;   geom->y1 = dy - gp->top;
1592                         geom->x2 = dx + gp->right;  geom->y2 = dy - gp->bottom;
1593                 }
1594                 glyph = gp;
1595                 int dx = x-geom->x0, dy = y-geom->y0 + config.size;
1596                 int dx1 = dx + glyph->left;
1597                 int dx2 = dx + glyph->right;
1598                 if( dx1 < geom->x1 ) geom->x1 = dx1;
1599                 if( dx2 > geom->x2 ) geom->x2 = dx2;
1600                 int dy1 = dy - glyph->top;
1601                 int dy2 = dy - glyph->bottom;
1602                 if( dy1 < geom->y1 ) geom->y1 = dy1;
1603                 if( dy2 > geom->y2 ) geom->y2 = dy2;
1604 //printf("charcode '%c'  %d,%d row bbox %d,%d %d,%d %d,%d\n",
1605 //  (int)wchar, x,y, geom->x0,geom->y0, geom->x1,geom->y1, geom->x2,geom->y2);
1606         }
1607         if( wlen > 0 && config.wtext[wlen-1] != '\n' ) {
1608                 ++geom;
1609                 geom->x0 = 0;
1610                 geom->y0 = text_h;
1611                 geom->x1 = geom->y1 = 0;
1612                 geom->x2 = geom->y2 = 0;
1613         }
1614 }
1615
1616 int TitleMain::draw_mask()
1617 {
1618         int old_visible_row1 = visible_row1;
1619         int old_visible_row2 = visible_row2;
1620
1621 // Determine y of visible text
1622         if(config.motion_strategy == BOTTOM_TO_TOP) {
1623 // printf("TitleMain::draw_mask 1 %d %lld %lld %lld\n",
1624 //      config.motion_strategy,
1625 //      get_source_position(),
1626 //      get_source_start(),
1627 //      config.prev_keyframe_position);
1628                 float magnitude = config.pixels_per_second *
1629                         (get_source_position() - config.prev_keyframe_position) /
1630                         PluginVClient::project_frame_rate;
1631                 if(config.loop) {
1632                         int loop_size = text_h + input->get_h();
1633                         magnitude -= (int)(magnitude / loop_size) * loop_size;
1634                 }
1635                 text_y1 = config.y + input->get_h() - magnitude;
1636         }
1637         else
1638         if(config.motion_strategy == TOP_TO_BOTTOM) {
1639                 float magnitude = config.pixels_per_second *
1640                         (get_source_position() - config.prev_keyframe_position) /
1641                         PluginVClient::project_frame_rate;
1642                 if(config.loop)
1643                 {
1644                         int loop_size = text_h + input->get_h();
1645                         magnitude -= (int)(magnitude / loop_size) * loop_size;
1646                 }
1647                 text_y1 = config.y + magnitude;
1648                 text_y1 -= text_h;
1649         }
1650         else if(config.vjustification == JUSTIFY_TOP) {
1651                 text_y1 = config.y;
1652         }
1653         else if(config.vjustification == JUSTIFY_MID) {
1654                 text_y1 = config.y + input->get_h() / 2 - text_h / 2;
1655         }
1656         else if(config.vjustification == JUSTIFY_BOTTOM) {
1657                 text_y1 = config.y + input->get_h() - text_h;
1658         }
1659
1660         text_y2 = text_y1 + text_h + 0.5;
1661
1662 // Determine x of visible text
1663         if(config.motion_strategy == RIGHT_TO_LEFT) {
1664                 float magnitude = config.pixels_per_second *
1665                         (get_source_position() - config.prev_keyframe_position) /
1666                         PluginVClient::project_frame_rate;
1667                 if(config.loop) {
1668                         int loop_size = text_w + input->get_w();
1669                         magnitude -= (int)(magnitude / loop_size) * loop_size;
1670                 }
1671                 text_x1 = config.x + (float)input->get_w() - magnitude;
1672         }
1673         else if(config.motion_strategy == LEFT_TO_RIGHT) {
1674                 float magnitude = config.pixels_per_second *
1675                         (get_source_position() - config.prev_keyframe_position) /
1676                         PluginVClient::project_frame_rate;
1677                 if(config.loop) {
1678                         int loop_size = text_w + input->get_w();
1679                         magnitude -= (int)(magnitude / loop_size) * loop_size;
1680                 }
1681                 text_x1 = config.x + -(float)text_w + magnitude;
1682         }
1683         else if(config.hjustification == JUSTIFY_LEFT) {
1684                 text_x1 = config.x;
1685         }
1686         else if(config.hjustification == JUSTIFY_MID) {
1687                 text_x1 = config.x + input->get_w() / 2 - text_w / 2;
1688         }
1689         else if(config.hjustification == JUSTIFY_RIGHT) {
1690                 text_x1 = config.x + input->get_w() - text_w;
1691         }
1692         text_x2 = text_x1 + text_w;
1693
1694         // bottom of this row is visible
1695         visible_row1 = 0;
1696         RowGeom *geom = 0;
1697         while( visible_row1 < text_rows ) {
1698                 geom = &row_geom[visible_row1];
1699                 int y0 = text_y1 + geom->bottom();
1700                 if( y0 > 0 ) break;
1701                 ++visible_row1;
1702         }
1703
1704         // top of next row is not visible
1705         visible_row2 = visible_row1;
1706         while( visible_row2 < text_rows ) {
1707                 geom = &row_geom[visible_row2];
1708                 int y0 = text_y1 + geom->top();
1709                 if( y0 >= input->get_h() ) break;
1710                 ++visible_row2;
1711         }
1712
1713         if( visible_row1 == visible_row2 ) return 1;
1714
1715 //printf("visible rows %d to %d\n", visible_row1, visible_row2);
1716         // Only use visible rows, get bbox including kerns
1717         // text origin, no kerning
1718         geom = &row_geom[visible_row1];
1719         extent.x0 = geom->x0;       extent.y0 = geom->y0;
1720         extent.x1 = geom->left();   extent.y1 = geom->top();
1721         extent.x2 = geom->right();  extent.y2 = geom->bottom();
1722
1723         for( int i=visible_row1; i<visible_row2; ++i ) {
1724                 geom = &row_geom[i];  int v;
1725                 if( (v=geom->left())   < extent.x1 ) extent.x1 = v;
1726                 if( (v=geom->top())    < extent.y1 ) extent.y1 = v;
1727                 if( (v=geom->right())  > extent.x2 ) extent.x2 = v;
1728                 if( (v=geom->bottom()) > extent.y2 ) extent.y2 = v;
1729         }
1730
1731 //printf("exts x0,y0=%d,%d  x1,y1=%d,%d  x2,y2=%d,%d text %f,%f %dx%d\n",
1732 // extent.x0,extent.y0, extent.x1,extent.y1, extent.x2,extent.y2,
1733 // text_x1,text_y1, text_w,text_h);
1734         // Only draw visible chars
1735         visible_char1 = visible_char2 = -1;
1736         int wlen = config.wlen;
1737         for(int i = 0; i < wlen; i++) {
1738                 char_pos_t *pos = char_pos + i;
1739                 if( pos->row < visible_row1 ) continue;
1740                 if( pos->row >= visible_row2 ) continue;
1741                 if(visible_char1 < 0) visible_char1 = i;
1742                 visible_char2 = i;
1743         }
1744         visible_char2++;
1745
1746         extent.x1 -= config.outline_size*2;
1747         extent.y1 -= config.outline_size*2;
1748         extent.x2 += abs(config.dropshadow) + config.outline_size*2;
1749         extent.y2 += abs(config.dropshadow) + config.outline_size*2;
1750
1751         // Determine mask geometry
1752         mask_w = extent.x2 - extent.x1;
1753         if( mask_w <= 0 ) return 1;
1754         mask_h = extent.y2 - extent.y1;
1755         if( mask_h <= 0 ) return 1;
1756
1757 //printf("TitleMain::draw_mask %d-%d frame %dx%d\n",
1758 //  visible_row1, visible_row2, mask_w,mask_h)
1759         int need_redraw = 0;
1760         if(text_mask && (text_mask->get_w() != mask_w || text_mask->get_h() != mask_h)) {
1761                 delete text_mask;         text_mask = 0;
1762                 delete text_mask_stroke;  text_mask_stroke = 0;
1763         }
1764
1765         if(!text_mask) {
1766 // Always use 8 bit because the glyphs are 8 bit
1767 // Need to set YUV to get clear_frame to set the right chroma.
1768                 int output_model = get_output()->get_color_model();
1769                 int color_model = BC_CModels::is_yuv(output_model) ? BC_YUVA8888 : BC_RGBA8888;
1770                 text_mask = new VFrame;
1771                 text_mask->set_use_shm(0);
1772                 text_mask->reallocate(0, -1, 0, 0, 0, mask_w, mask_h, color_model, -1);
1773                 float drop = abs(config.dropshadow);
1774                 int drop_w = mask_w + drop;
1775                 int drop_h = mask_h + drop;
1776                 text_mask_stroke = new VFrame;
1777                 text_mask_stroke->set_use_shm(0);
1778                 text_mask_stroke->reallocate(0, -1, 0, 0, 0, drop_w, drop_h, color_model, -1);
1779                 need_redraw = 1;
1780         }
1781
1782 // Draw on text mask if it has changed
1783         if( need_redraw ||
1784             old_visible_row1 != visible_row1 ||
1785             old_visible_row2 != visible_row2 ) {
1786 //printf("redraw %d to %d   %d,%d  %d,%d - %d,%d\n", visible_char1,visible_char2,
1787 //  extent.x0, extent.y0, extent.x1,extent.y1, extent.x2,extent.y2);
1788
1789                 text_mask->clear_frame();
1790                 text_mask_stroke->clear_frame();
1791 #if 0
1792                 unsigned char *data = text_mask->get_data(); // draw bbox on text_mask
1793                 for( int x=0; x<mask_w; ++x ) data[4*x+3] = 0xff;
1794                 for( int x=0; x<mask_w; ++x ) data[4*((mask_h-1)*mask_w+x)+3] = 0xff;
1795                 for( int y=0; y<mask_h; ++y ) data[4*mask_w*y+3] = 0xff;
1796                 for( int y=0; y<mask_h; ++y ) data[4*(mask_w*y + mask_w-1)+3] = 0xff;
1797 #endif
1798                 if(!title_engine)
1799                         title_engine = new TitleEngine(this, cpus);
1800
1801 // Draw dropshadow first
1802                 if(config.dropshadow) {
1803                         title_engine->do_dropshadow = 1;
1804                         title_engine->set_package_count(visible_char2 - visible_char1);
1805                         title_engine->process_packages();
1806                 }
1807
1808 // Then draw foreground
1809                 title_engine->do_dropshadow = 0;
1810                 title_engine->set_package_count(visible_char2 - visible_char1);
1811                 title_engine->process_packages();
1812
1813 // Convert to text outlines
1814                 if(config.outline_size > 0) {
1815                         if(outline_mask &&
1816                             (text_mask->get_w() != outline_mask->get_w() ||
1817                              text_mask->get_h() != outline_mask->get_h())) {
1818                                 delete outline_mask;  outline_mask = 0;
1819                         }
1820
1821                         if(!outline_mask) {
1822                                 outline_mask = new VFrame;
1823                                 outline_mask->set_use_shm(0);
1824                                 outline_mask->reallocate(0, -1, 0, 0, 0,
1825                                         text_mask->get_w(), text_mask->get_h(),
1826                                         text_mask->get_color_model(), -1);
1827                         }
1828                         if(!outline_engine) outline_engine =
1829                                 new TitleOutlineEngine(this, cpus);
1830                         outline_engine->do_outline();
1831                 }
1832         }
1833
1834         return 0;
1835 }
1836
1837 void TitleMain::overlay_mask()
1838 {
1839
1840 //printf("TitleMain::overlay_mask 1\n");
1841         alpha = 0x100;
1842         if(!EQUIV(config.fade_in, 0))
1843         {
1844                 int fade_len = lroundf(config.fade_in * PluginVClient::project_frame_rate);
1845                 int fade_position = get_source_position() - config.prev_keyframe_position;
1846
1847                 if(fade_position >= 0 && fade_position < fade_len)
1848                 {
1849                         alpha = lroundf(256.0f * fade_position / fade_len);
1850                 }
1851         }
1852         if(!EQUIV(config.fade_out, 0))
1853         {
1854                 int fade_len = lroundf(config.fade_out * PluginVClient::project_frame_rate);
1855                 int fade_position = config.next_keyframe_position - get_source_position();
1856
1857
1858                 if(fade_position >= 0 && fade_position < fade_len)
1859                 {
1860                         alpha = lroundf(256.0f * fade_position / fade_len);
1861                 }
1862         }
1863
1864         if(!translate)
1865                 translate = new TitleTranslate(this, cpus);
1866
1867         if(config.dropshadow)
1868         {
1869                 text_x1 += config.dropshadow;
1870                 if(text_x1 < input->get_w() && text_x1 + text_w > 0)
1871                 {
1872 // Do 2 passes if dropshadow.
1873                         int temp_color = config.color;
1874                         config.color = 0x0;
1875                         translate->run_packages();
1876                         config.color = temp_color;
1877                 }
1878                 text_x1 -= config.dropshadow;
1879         }
1880 //printf("TitleMain::overlay_mask 1\n");
1881
1882         if(text_x1 < input->get_w() && text_x1 + text_w > 0) {
1883                 translate->run_packages();
1884                 if (config.stroke_width >= ZERO && (config.style & BC_FONT_OUTLINE)) {
1885                         int temp_color = config.color;
1886                         VFrame *tmp_text_mask = this->text_mask;
1887                         config.color = config.color_stroke;
1888                         this->text_mask = this->text_mask_stroke;
1889
1890                         translate->run_packages();
1891                         config.color = temp_color;
1892                         this->text_mask = tmp_text_mask;
1893                 }
1894         }
1895 //printf("TitleMain::overlay_mask 200\n");
1896 }
1897
1898 void TitleMain::get_color_components(int *r, int *g, int *b, int *a, int is_outline)
1899 {
1900         int color = is_outline ? config.outline_color : config.color;
1901         unsigned char r_in = color >> 16;
1902         unsigned char g_in = color >> 8;
1903         unsigned char b_in = color;
1904         *a = is_outline ? config.outline_alpha : config.alpha;
1905
1906         switch(output->get_color_model()) {
1907                 case BC_YUV888:
1908                         yuv.rgb_to_yuv_8(r_in, g_in, b_in, *r, *g, *b);
1909                         break;
1910                 case BC_YUVA8888:
1911                         yuv.rgb_to_yuv_8(r_in, g_in, b_in, *r, *g, *b);
1912                         break;
1913                 default:
1914                         *r = r_in;  *g = g_in;  *b = b_in;
1915                         break;
1916         }
1917 }
1918
1919 void TitleMain::clear_glyphs()
1920 {
1921 //printf("TitleMain::clear_glyphs 1\n");
1922         glyphs.remove_all_objects();
1923 }
1924
1925 const char* TitleMain::motion_to_text(int motion)
1926 {
1927         switch(motion)
1928         {
1929                 case NO_MOTION: return _("No motion"); break;
1930                 case BOTTOM_TO_TOP: return _("Bottom to top"); break;
1931                 case TOP_TO_BOTTOM: return _("Top to bottom"); break;
1932                 case RIGHT_TO_LEFT: return _("Right to left"); break;
1933                 case LEFT_TO_RIGHT: return _("Left to right"); break;
1934         }
1935         return "";
1936 }
1937
1938 int TitleMain::text_to_motion(const char *text)
1939 {
1940         for(int i = 0; i < TOTAL_PATHS; i++)
1941         {
1942                 if(!strcasecmp(motion_to_text(i), text)) return i;
1943         }
1944         return 0;
1945 }
1946
1947 void TitleMain::reset_render()
1948 {
1949         delete text_mask;          text_mask = 0;
1950         delete glyph_engine;       glyph_engine = 0;
1951         delete [] char_pos;        char_pos = 0;
1952         delete text_mask_stroke;   text_mask_stroke = 0;
1953         delete [] row_geom;        row_geom = 0;
1954         row_geom_size = 0;
1955         visible_row1 = 0;          visible_row2 = 0;
1956         visible_char1 = 0;         visible_char2 = 0;
1957         text_rows = 0;
1958         clear_glyphs();
1959         if(freetype_face) {
1960                 FT_Done_Face(freetype_face);
1961                 freetype_face = 0;
1962         }
1963 }
1964
1965 int TitleMain::init_freetype()
1966 {
1967         if(!freetype_library)
1968                 FT_Init_FreeType(&freetype_library);
1969         if(!freetype_face) {
1970                 BC_FontEntry *font = get_font();
1971                 if(load_freetype_face(freetype_library, freetype_face, font->path)) {
1972                         printf("TitleMain::process_realtime %s: FT_New_Face failed.\n",
1973                                 font->displayname);
1974                         return 1;
1975                 }
1976                 FT_Set_Pixel_Sizes(freetype_face, config.size, 0);
1977         }
1978         return 0;
1979 }
1980
1981 int TitleMain::process_realtime(VFrame *input_ptr, VFrame *output_ptr)
1982 {
1983         int result = 0;
1984         input = input_ptr;
1985         output = output_ptr;
1986
1987         need_reconfigure |= load_configuration();
1988
1989 // Check boundaries
1990         if(config.size <= 0 || config.size >= 2048)
1991                 config.size = 72;
1992         if(config.stroke_width < 0 || config.stroke_width >= 512)
1993                 config.stroke_width = 0.0;
1994         if(!config.wlen && !config.timecode)
1995                 return 0;
1996         if(!strlen(config.encoding))
1997                 strcpy(config.encoding, DEFAULT_ENCODING);
1998
1999 // Always synthesize text and redraw it for timecode
2000         if(config.timecode)
2001         {
2002                 int64_t rendered_frame = get_source_position();
2003                 if (get_direction() == PLAY_REVERSE)
2004                         rendered_frame -= 1;
2005
2006                 char text[BCTEXTLEN];
2007                 Units::totext(text,
2008                                 (double)rendered_frame / PluginVClient::project_frame_rate,
2009                                 config.timecode_format,
2010                                 PluginVClient::get_project_samplerate(),
2011                                 PluginVClient::get_project_framerate(),
2012                                 16);
2013                 config.to_wtext(config.encoding, text, strlen(text)+1);
2014                 need_reconfigure = 1;
2015         }
2016
2017 // printf("TitleMain::process_realtime %d need_reconfigure=%d\n",
2018 // __LINE__,
2019 // need_reconfigure);
2020
2021 // Handle reconfiguration
2022         if(need_reconfigure) {
2023                 reset_render();
2024                 result = init_freetype();
2025                 if(!result) {
2026 //PRINT_TRACE
2027                         load_glyphs();
2028                         get_total_extents();
2029                         need_reconfigure = 0;
2030                 }
2031         }
2032
2033         if(!result) {
2034 //PRINT_TRACE
2035 // Determine region of text visible on the output and draw mask
2036                 result = draw_mask();
2037         }
2038
2039
2040 // Overlay mask on output
2041         if(!result) {
2042 //PRINT_TRACE
2043                 overlay_mask();
2044         }
2045
2046         return 0;
2047 }
2048
2049 void TitleMain::update_gui()
2050 {
2051         if(thread)
2052         {
2053                 int reconfigure = load_configuration();
2054                 if(reconfigure)
2055                 {
2056                         TitleWindow *window = (TitleWindow*)thread->window;
2057                         window->lock_window("TitleMain::update_gui");
2058                         window->update();
2059                         window->unlock_window();
2060                         window->color_thread->update_gui(config.color, 0);
2061                         window->unlock_window();
2062                 }
2063         }
2064 }
2065
2066 int TitleMain::load_configuration()
2067 {
2068         KeyFrame *prev_keyframe, *next_keyframe;
2069         prev_keyframe = get_prev_keyframe(get_source_position());
2070         next_keyframe = get_next_keyframe(get_source_position());
2071
2072         TitleConfig old_config, prev_config, next_config;
2073         old_config.copy_from(config);
2074         read_data(prev_keyframe);
2075         prev_config.copy_from(config);
2076         read_data(next_keyframe);
2077         next_config.copy_from(config);
2078
2079         config.prev_keyframe_position = prev_keyframe->position;
2080         config.next_keyframe_position = next_keyframe->position;
2081
2082         // if no previous keyframe exists, it should be start of the plugin, not start of the track
2083         if(config.next_keyframe_position == config.prev_keyframe_position)
2084                 config.next_keyframe_position = get_source_start() + get_total_len();
2085         if (config.prev_keyframe_position == 0)
2086                 config.prev_keyframe_position = get_source_start();
2087 // printf("TitleMain::load_configuration 10 %d %d\n",
2088 // config.prev_keyframe_position,
2089 // config.next_keyframe_position);
2090
2091         config.interpolate(prev_config,
2092                 next_config,
2093                 (next_keyframe->position == prev_keyframe->position) ?
2094                         get_source_position() :
2095                         prev_keyframe->position,
2096                 (next_keyframe->position == prev_keyframe->position) ?
2097                         get_source_position() + 1 :
2098                         next_keyframe->position,
2099                 get_source_position());
2100
2101         if(!config.equivalent(old_config))
2102                 return 1;
2103         return 0;
2104 }
2105
2106
2107 void TitleMain::save_data(KeyFrame *keyframe)
2108 {
2109         FileXML output;
2110
2111         output.set_shared_output(keyframe->get_data(), MESSAGESIZE);
2112         output.tag.set_title("TITLE");
2113         output.tag.set_property("FONT", config.font);
2114         output.tag.set_property("ENCODING", config.encoding);
2115         output.tag.set_property("STYLE", (int64_t)config.style);
2116         output.tag.set_property("SIZE", config.size);
2117         output.tag.set_property("COLOR", config.color);
2118         output.tag.set_property("COLOR_STROKE", config.color_stroke);
2119         output.tag.set_property("STROKE_WIDTH", config.stroke_width);
2120         output.tag.set_property("OUTLINE_COLOR", config.outline_color);
2121         output.tag.set_property("ALPHA", config.alpha);
2122         output.tag.set_property("OUTLINE_ALPHA", config.outline_alpha);
2123         output.tag.set_property("MOTION_STRATEGY", config.motion_strategy);
2124         output.tag.set_property("LOOP", config.loop);
2125         output.tag.set_property("LINE_PITCH", config.line_pitch);
2126         output.tag.set_property("PIXELS_PER_SECOND", config.pixels_per_second);
2127         output.tag.set_property("HJUSTIFICATION", config.hjustification);
2128         output.tag.set_property("VJUSTIFICATION", config.vjustification);
2129         output.tag.set_property("FADE_IN", config.fade_in);
2130         output.tag.set_property("FADE_OUT", config.fade_out);
2131         output.tag.set_property("TITLE_X", config.x);
2132         output.tag.set_property("TITLE_Y", config.y);
2133         output.tag.set_property("DROPSHADOW", config.dropshadow);
2134         output.tag.set_property("OUTLINE_SIZE", config.outline_size);
2135         output.tag.set_property("TIMECODE", config.timecode);
2136         output.tag.set_property("TIMECODEFORMAT", config.timecode_format);
2137         output.tag.set_property("WINDOW_W", config.window_w);
2138         output.tag.set_property("WINDOW_H", config.window_h);
2139         output.append_tag();
2140         output.append_newline();
2141         char text[BCTEXTLEN];
2142         int text_len = BC_Resources::encode(
2143                 BC_Resources::wide_encoding, DEFAULT_ENCODING,
2144                 (char*)config.wtext, config.wlen*sizeof(wchar_t),
2145                 text, sizeof(text));
2146         output.append_text(text, text_len);
2147         output.tag.set_title("/TITLE");
2148         output.append_tag();
2149         output.append_newline();
2150         output.terminate_string();
2151 //printf("TitleMain::save_data 1\n%s\n", output.string);
2152 //printf("TitleMain::save_data 2\n%s\n", config.text);
2153 }
2154
2155 void TitleMain::read_data(KeyFrame *keyframe)
2156 {
2157         FileXML input;
2158
2159         input.set_shared_input(keyframe->get_data(), strlen(keyframe->get_data()));
2160
2161         int result = 0;
2162
2163         config.prev_keyframe_position = keyframe->position;
2164         while(!result)
2165         {
2166                 result = input.read_tag();
2167                 if( result ) break;
2168
2169                 if(input.tag.title_is("TITLE")) {
2170                         input.tag.get_property("FONT", config.font);
2171                         input.tag.get_property("ENCODING", config.encoding);
2172                         config.style = input.tag.get_property("STYLE", (int64_t)config.style);
2173                         config.size = input.tag.get_property("SIZE", config.size);
2174                         config.color = input.tag.get_property("COLOR", config.color);
2175                         config.color_stroke = input.tag.get_property("COLOR_STROKE", config.color_stroke);
2176                         config.stroke_width = input.tag.get_property("STROKE_WIDTH", config.stroke_width);
2177                         config.outline_color = input.tag.get_property("OUTLINE_COLOR", config.outline_color);
2178                         config.alpha = input.tag.get_property("ALPHA", config.alpha);
2179                         config.outline_alpha = input.tag.get_property("OUTLINE_ALPHA", config.outline_alpha);
2180                         config.motion_strategy = input.tag.get_property("MOTION_STRATEGY", config.motion_strategy);
2181                         config.loop = input.tag.get_property("LOOP", config.loop);
2182                         config.line_pitch = input.tag.get_property("LINE_PITCH", config.line_pitch);
2183                         config.pixels_per_second = input.tag.get_property("PIXELS_PER_SECOND", config.pixels_per_second);
2184                         config.hjustification = input.tag.get_property("HJUSTIFICATION", config.hjustification);
2185                         config.vjustification = input.tag.get_property("VJUSTIFICATION", config.vjustification);
2186                         config.fade_in = input.tag.get_property("FADE_IN", config.fade_in);
2187                         config.fade_out = input.tag.get_property("FADE_OUT", config.fade_out);
2188                         config.x = input.tag.get_property("TITLE_X", config.x);
2189                         config.y = input.tag.get_property("TITLE_Y", config.y);
2190                         config.dropshadow = input.tag.get_property("DROPSHADOW", config.dropshadow);
2191                         config.outline_size = input.tag.get_property("OUTLINE_SIZE", config.outline_size);
2192                         config.timecode = input.tag.get_property("TIMECODE", config.timecode);
2193                         config.timecode_format = input.tag.get_property("TIMECODEFORMAT", config.timecode_format);
2194                         config.window_w = input.tag.get_property("WINDOW_W", config.window_w);
2195                         config.window_h = input.tag.get_property("WINDOW_H", config.window_h);
2196                         const char *text = input.read_text();
2197                         config.to_wtext(config.encoding, text, strlen(text)+1);
2198                 }
2199                 else if(input.tag.title_is("/TITLE")) {
2200                         result = 1;
2201                 }
2202         }
2203 }