cinelerra-5.0/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 "colormodels.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 = 10;
  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 = (int)(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
 547         int x_in = 0, y_in = 0;
 548         int x_out = x + glyph->left;
 549         if( x_out < 0 ) { x_in = -x_out;  x_out = 0; }
 550         if( x_out+glyph_w > output_w ) glyph_w = output_w-x_out;
 551         if( x_in >= glyph_w || x_out >= output_w ) return;
 552         int y_out = y + baseline - glyph->top;
 553         if( y_out < 0 ) { y_in = -y_out;  y_out = 0; }
 554         if( y_out+glyph_h > output_h ) glyph_h = output_h-y_out;
 555         if( y_in >= glyph_h || y_out >= output_h ) return;
 556
 557         if(engine->do_dropshadow) {
 558                 while( y_in < glyph_h && y_out < output_h ) {
 559                         unsigned char *in_row = in_rows[y_in];
 560                         unsigned char *out_row = out_rows[y_out];
 561                         for( int xin=x_in,xout=x_out*4+3; xin<glyph_w; ++xin,xout+=4 ) {
 562                                 out_row[xout] = in_row[xin];
 563                         }
 564                         ++y_in;  ++y_out;
 565                 }
 566                 return;
 567         }
 568
 569         int r, g, b, a;
 570         plugin->get_color_components(&r, &g, &b, &a, 0);
 571         int outline = plugin->config.outline_size;
 572         if(outline) a = 0xff;
 573
 574         while( y_in < glyph_h && y_out < output_h ) {
 575                 unsigned char *in_row = in_rows[y_in];
 576                 unsigned char *out_row = out_rows[y_out];
 577                 for( int xin=x_in,xout=x_out*4+0; xin<glyph_w; ++xin,xout+=4 ) {
 578                         int in_a = in_row[xin], out_a = out_row[xout+3];
 579                         if( in_a + out_a == 0 ) continue;  // alpha blundering
 580                         int opacity = in_a * a, transp = out_a * (0xff - opacity/0xff);
 581                         out_row[xout+0] = (opacity * r + transp * out_row[xout+0]) / (0xff*0xff);
 582                         out_row[xout+1] = (opacity * g + transp * out_row[xout+1]) / (0xff*0xff);
 583                         out_row[xout+2] = (opacity * b + transp * out_row[xout+2]) / (0xff*0xff);
 584                         out_row[xout+3] = (opacity + transp) / 0xff;
 585                 }
 586                 ++y_in;  ++y_out;
 587         }
 588 }
 589
 590
 591 void TitleUnit::process_package(LoadPackage *package)
 592 {
 593         TitlePackage *pkg = (TitlePackage*)package;
 594
 595         if( pkg->char_code == 0 || pkg->char_code == '\n') return;
 596         TitleGlyph *glyph = plugin->get_glyph(pkg->char_code);
 597         if( !glyph ) return;
 598         draw_glyph(plugin->text_mask, glyph->data, glyph, pkg->x, pkg->y);
 599         if(plugin->config.stroke_width >= ZERO && (plugin->config.style & BC_FONT_OUTLINE))
 600                 draw_glyph(plugin->text_mask_stroke, glyph->data_stroke, glyph, pkg->x, pkg->y);
 601 }
 602
 603 TitleEngine::TitleEngine(TitleMain *plugin, int cpus)
 604  : LoadServer(cpus, cpus)
 605 {
 606         this->plugin = plugin;
 607 }
 608
 609 void TitleEngine::init_packages()
 610 {
 611         int current_package = 0;
 612         int dx = plugin->config.outline_size - plugin->extent.x1;
 613         int dy = plugin->config.outline_size - plugin->extent.y1;
 614         for(int i = plugin->visible_char1; i < plugin->visible_char2; i++) {
 615                 TitlePackage *pkg = (TitlePackage*)get_package(current_package++);
 616                 char_pos_t *pos = plugin->char_pos + i;
 617                 pkg->x = pos->x + dx;
 618                 pkg->y = pos->y + dy;
 619                 pkg->char_code = plugin->config.wtext[i];
 620 //printf("draw '%c' at %d,%d\n",(int)pkg->char_code, pkg->x, pkg->y);
 621         }
 622 }
 623
 624 LoadClient* TitleEngine::new_client()
 625 {
 626         return new TitleUnit(plugin, this);
 627 }
 628
 629 LoadPackage* TitleEngine::new_package()
 630 {
 631         return new TitlePackage;
 632 }
 633
 634 void TitleTranslateUnit::translation_array_f(transfer_table_f* &table,
 635         float out_x1,
 636         float out_x2,
 637         float in_x1,
 638         float in_x2,
 639         int in_total,
 640         int out_total,
 641         int &out_x1_int,
 642         int &out_x2_int)
 643 {
 644         int out_w_int;
 645         //float offset = out_x1 - in_x1;
 646
 647         out_x1_int = (int)out_x1;
 648         out_x2_int = MIN((int)ceil(out_x2), out_total);
 649         out_w_int = out_x2_int - out_x1_int;
 650
 651         table = new transfer_table_f[out_w_int];
 652         bzero(table, sizeof(transfer_table_f) * out_w_int);
 653
 654         float in_x = in_x1;
 655         for(int out_x = out_x1_int; out_x < out_x2_int; out_x++)
 656         {
 657                 transfer_table_f *entry = &table[out_x - out_x1_int];
 658
 659                 entry->in_x1 = (int)in_x;
 660                 entry->in_x2 = (int)in_x + 1;
 661
 662 // Get fraction of output pixel to fill
 663                 entry->output_fraction = 1;
 664
 665                 if(out_x1 > out_x)
 666                 {
 667                         entry->output_fraction -= out_x1 - out_x;
 668                 }
 669
 670                 if(out_x2 < out_x + 1)
 671                 {
 672                         entry->output_fraction = (out_x2 - out_x);
 673                 }
 674
 675 // Advance in_x until out_x_fraction is filled
 676                 float out_x_fraction = entry->output_fraction;
 677                 float in_x_fraction = floor(in_x + 1) - in_x;
 678
 679                 if(out_x_fraction <= in_x_fraction)
 680                 {
 681                         entry->in_fraction1 = out_x_fraction;
 682                         entry->in_fraction2 = 0.0;
 683                         in_x += out_x_fraction;
 684                 }
 685                 else
 686                 {
 687                         entry->in_fraction1 = in_x_fraction;
 688                         in_x += out_x_fraction;
 689                         entry->in_fraction2 = in_x - floor(in_x);
 690                 }
 691
 692 // Clip in_x and zero out fraction.  This doesn't work for YUV.
 693                 if(entry->in_x2 >= in_total)
 694                 {
 695                         entry->in_x2 = in_total - 1;
 696                         entry->in_fraction2 = 0.0;
 697                 }
 698
 699                 if(entry->in_x1 >= in_total)
 700                 {
 701                         entry->in_x1 = in_total - 1;
 702                         entry->in_fraction1 = 0.0;
 703                 }
 704         }
 705 }
 706
 707
 708
 709 // Copy a single character to the text mask
 710 TitleOutlinePackage::TitleOutlinePackage()
 711  : LoadPackage()
 712 {
 713 }
 714
 715
 716 TitleOutlineUnit::TitleOutlineUnit(TitleMain *plugin, TitleOutlineEngine *server)
 717  : LoadClient(server)
 718 {
 719         this->plugin = plugin;
 720         this->engine = server;
 721 }
 722
 723 void TitleOutlineUnit::process_package(LoadPackage *package)
 724 {
 725         TitleOutlinePackage *pkg = (TitleOutlinePackage*)package;
 726         int r, g, b, outline_a;
 727         plugin->get_color_components(&r, &g, &b, &outline_a, 1);
 728         int title_r, title_g, title_b, title_a;
 729         plugin->get_color_components(&title_r, &title_g, &title_b, &title_a, 0);
 730         unsigned char **outline_rows = plugin->outline_mask->get_rows();
 731         unsigned char **text_rows = plugin->text_mask->get_rows();
 732         int mask_w1 = plugin->text_mask->get_w()-1;
 733         int mask_h1 = plugin->text_mask->get_h()-1;
 734         int ofs = plugin->config.outline_size;
 735
 736         if(engine->pass == 0) {
 737 // get max alpha under outline size macropixel
 738                 for(int y = pkg->y1; y < pkg->y2; y++) {
 739                         unsigned char *out_row = outline_rows[y];
 740                         int y1 = y - ofs, y2 = y + ofs;
 741                         CLAMP(y1, 0, mask_h1);  CLAMP(y2, 0, mask_h1);
 742                         for(int x = 0; x < plugin->text_mask->get_w(); x++) {
 743                                 int x1 = x - ofs, x2 = x + ofs;
 744                                 CLAMP(x1, 0, mask_w1);  CLAMP(x2, 0, mask_w1);
 745
 746                                 int max_a = 0;
 747                                 for(int yy = y1; yy <= y2; yy++) {
 748                                         unsigned char *text_row = text_rows[yy];
 749                                         for(int xx = x1; xx <= x2; ++xx) {
 750                                                 unsigned char *pixel = text_row + xx*4;
 751                                                 if(pixel[3] > max_a) max_a = pixel[3];
 752                                         }
 753                                 }
 754
 755                                 unsigned char *out = out_row + x*4;
 756                                 out[0] = r;  out[1] = g;  out[2] = b;
 757                                 out[3] = (max_a * outline_a) / 0xff;
 758                         }
 759                 }
 760                 return;
 761         }
 762         else {
 763 // Overlay text mask on top of outline mask
 764                 for(int y = pkg->y1; y < pkg->y2; y++) {
 765                         unsigned char *outline_row = outline_rows[y];
 766                         unsigned char *text_row = text_rows[y];
 767                         for(int x = 0; x < plugin->text_mask->get_w(); x++) {
 768                                 unsigned char *out = text_row + x * 4;
 769                                 unsigned char *inp = outline_row + x * 4;
 770                                 int out_a = out[3], in_a = inp[3];
 771                                 int transparency = in_a * (0xff - out_a) / 0xff;
 772                                 out[0] = (out[0] * out_a + inp[0] * transparency) / 0xff;
 773                                 out[1] = (out[1] * out_a + inp[1] * transparency) / 0xff;
 774                                 out[2] = (out[2] * out_a + inp[2] * transparency) / 0xff;
 775                                 out[3] = out_a + transparency;
 776                         }
 777                 }
 778         }
 779 }
 780
 781 TitleOutlineEngine::TitleOutlineEngine(TitleMain *plugin, int cpus)
 782  : LoadServer(cpus, cpus)
 783 {
 784         this->plugin = plugin;
 785 }
 786
 787 void TitleOutlineEngine::init_packages()
 788 {
 789         int mask_h = plugin->text_mask->get_h();
 790         if( !mask_h ) return;
 791         int py1 = 0, py2 = 0;
 792         int pkgs = get_total_packages();
 793         for( int i=0; i<pkgs; py1=py2 ) {
 794                 TitleOutlinePackage *pkg = (TitleOutlinePackage*)get_package(i);
 795                 py2 = (++i * mask_h)/ pkgs;
 796                 pkg->y1 = py1;  pkg->y2 = py2;
 797         }
 798 }
 799
 800 void TitleOutlineEngine::do_outline()
 801 {
 802         pass = 0;  process_packages();
 803         pass = 1;  process_packages();
 804 }
 805
 806 LoadClient* TitleOutlineEngine::new_client()
 807 {
 808         return new TitleOutlineUnit(plugin, this);
 809 }
 810
 811 LoadPackage* TitleOutlineEngine::new_package()
 812 {
 813         return new TitleOutlinePackage;
 814 }
 815
 816
 817
 818
 819 TitleTranslatePackage::TitleTranslatePackage()
 820  : LoadPackage()
 821 {
 822         y1 = y2 = 0;
 823 }
 824
 825
 826 TitleTranslateUnit::TitleTranslateUnit(TitleMain *plugin, TitleTranslate *server)
 827  : LoadClient(server)
 828 {
 829         this->plugin = plugin;
 830 }
 831
 832 void TitleTranslate::run_packages()
 833 {
 834         output_w = plugin->output->get_w();
 835         output_h = plugin->output->get_h();
 836
 837         float x1 = plugin->text_x1 + plugin->extent.x1;
 838         float x2 = plugin->text_x1 + plugin->extent.x2;
 839         if (x2 <= 0 || x1 >= x2 || x1 >= output_w) return;
 840
 841         float y1 = plugin->text_y1 + plugin->extent.y1;
 842         float y2 = plugin->text_y1 + plugin->extent.y2;
 843         if (y2 <= 0 || y1 >= y2 || y1 >= output_h) return;
 844
 845         process_packages();
 846 }
 847
 848
 849
 850
 851 #define TRANSLATE(type, max, components) \
 852 { \
 853         unsigned char **in_rows = plugin->text_mask->get_rows(); \
 854         type **out_rows = (type**)plugin->output->get_rows(); \
 855  \
 856         for(int i = pkg->y1; i < pkg->y2; i++) \
 857         { \
 858                 if(i + server->out_y1_int >= 0 && \
 859                         i + server->out_y1_int < server->output_h) \
 860                 { \
 861                         int in_y1, in_y2; \
 862                         float y_fraction1, y_fraction2; \
 863                         in_y1 = server->y_table[i].in_x1; \
 864                         in_y2 = server->y_table[i].in_x2; \
 865                         y_fraction1 = server->y_table[i].in_fraction1; \
 866                         y_fraction2 = server->y_table[i].in_fraction2; \
 867                         unsigned char *in_row1 = in_rows[in_y1]; \
 868                         unsigned char *in_row2 = in_rows[in_y2]; \
 869                         type *out_row = out_rows[i + server->out_y1_int]; \
 870  \
 871                         for(int j = server->out_x1_int; j < server->out_x2_int; j++) \
 872                         { \
 873                                 if(j >= 0 && j < server->output_w) \
 874                                 { \
 875                                         int in_x1; \
 876                                         int in_x2; \
 877                                         float x_fraction1; \
 878                                         float x_fraction2; \
 879                                         in_x1 =  \
 880                                                 server->x_table[j - server->out_x1_int].in_x1; \
 881                                         in_x2 =  \
 882                                                 server->x_table[j - server->out_x1_int].in_x2; \
 883                                         x_fraction1 =  \
 884                                                 server->x_table[j - server->out_x1_int].in_fraction1; \
 885                                         x_fraction2 =  \
 886                                                 server->x_table[j - server->out_x1_int].in_fraction2; \
 887  \
 888                                         float fraction1 = x_fraction1 * y_fraction1; \
 889                                         float fraction2 = x_fraction2 * y_fraction1; \
 890                                         float fraction3 = x_fraction1 * y_fraction2; \
 891                                         float fraction4 = x_fraction2 * y_fraction2; \
 892                                         type input_r = (type)(in_row1[in_x1 * 4 + 0] * fraction1 +  \
 893                                                                 in_row1[in_x2 * 4 + 0] * fraction2 +  \
 894                                                                 in_row2[in_x1 * 4 + 0] * fraction3 +  \
 895                                                                 in_row2[in_x2 * 4 + 0] * fraction4); \
 896                                         type input_g = (type)(in_row1[in_x1 * 4 + 1] * fraction1 +  \
 897                                                                 in_row1[in_x2 * 4 + 1] * fraction2 +  \
 898                                                                 in_row2[in_x1 * 4 + 1] * fraction3 +  \
 899                                                                 in_row2[in_x2 * 4 + 1] * fraction4); \
 900                                         type input_b = (type)(in_row1[in_x1 * 4 + 2] * fraction1 +  \
 901                                                                 in_row1[in_x2 * 4 + 2] * fraction2 +  \
 902                                                                 in_row2[in_x1 * 4 + 2] * fraction3 +  \
 903                                                                 in_row2[in_x2 * 4 + 2] * fraction4); \
 904                                         type input_a = (type)(in_row1[in_x1 * 4 + 3] * fraction1 +  \
 905                                                                 in_row1[in_x2 * 4 + 3] * fraction2 +  \
 906                                                                 in_row2[in_x1 * 4 + 3] * fraction3 +  \
 907                                                                 in_row2[in_x2 * 4 + 3] * fraction4); \
 908 /* Plugin alpha is actually 0 - 0x100 */ \
 909                                         input_a = input_a * plugin->alpha / 0x100; \
 910                                         type transparency; \
 911  \
 912  \
 913                                         if(components == 4) \
 914                                         { \
 915                                                 transparency = out_row[j * components + 3] * (max - input_a) / max; \
 916                                                 out_row[j * components + 0] =  \
 917                                                         (input_r * input_a + out_row[j * components + 0] * transparency) / max; \
 918                                                 out_row[j * components + 1] =  \
 919                                                         (input_g * input_a + out_row[j * components + 1] * transparency) / max; \
 920                                                 out_row[j * components + 2] =  \
 921                                                         (input_b * input_a + out_row[j * components + 2] * transparency) / max; \
 922                                                 out_row[j * components + 3] =  \
 923                                                         MAX(input_a, out_row[j * components + 3]); \
 924                                         } \
 925                                         else \
 926                                         { \
 927                                                 transparency = max - input_a; \
 928                                                 out_row[j * components + 0] =  \
 929                                                         (input_r * input_a + out_row[j * components + 0] * transparency) / max; \
 930                                                 out_row[j * components + 1] =  \
 931                                                         (input_g * input_a + out_row[j * components + 1] * transparency) / max; \
 932                                                 out_row[j * components + 2] =  \
 933                                                         (input_b * input_a + out_row[j * components + 2] * transparency) / max; \
 934                                         } \
 935                                 } \
 936                         } \
 937                 } \
 938         } \
 939 }
 940
 941 #define TRANSLATEA(type, max, components, r, g, b) \
 942 { \
 943         unsigned char **in_rows = plugin->text_mask->get_rows(); \
 944         type **out_rows = (type**)plugin->output->get_rows(); \
 945  \
 946         for(int i = pkg->y1; i < pkg->y2; i++) \
 947         { \
 948                 if(i + server->out_y1_int >= 0 && \
 949                         i + server->out_y1_int < server->output_h) \
 950                 { \
 951                         unsigned char *in_row = in_rows[i]; \
 952                         type *out_row = out_rows[i + server->out_y1_int]; \
 953  \
 954                         for(int j = server->out_x1; j < server->out_x2_int; j++) \
 955                         { \
 956                                 if(j  >= 0 && \
 957                                         j < server->output_w) \
 958                                 { \
 959                                         int input = (int)(in_row[j - server->out_x1]);  \
 960  \
 961                                         input *= plugin->alpha; \
 962 /* Alpha is 0 - 256 */ \
 963                                         input >>= 8; \
 964  \
 965                                         int anti_input = 0xff - input; \
 966                                         if(components == 4) \
 967                                         { \
 968                                                 out_row[j * components + 0] =  \
 969                                                         (r * input + out_row[j * components + 0] * anti_input) / 0xff; \
 970                                                 out_row[j * components + 1] =  \
 971                                                         (g * input + out_row[j * components + 1] * anti_input) / 0xff; \
 972                                                 out_row[j * components + 2] =  \
 973                                                         (b * input + out_row[j * components + 2] * anti_input) / 0xff; \
 974                                                 if(max == 0xffff) \
 975                                                         out_row[j * components + 3] =  \
 976                                                                 MAX((input << 8) | input, out_row[j * components + 3]); \
 977                                                 else \
 978                                                         out_row[j * components + 3] =  \
 979                                                                 MAX(input, out_row[j * components + 3]); \
 980                                         } \
 981                                         else \
 982                                         { \
 983                                                 out_row[j * components + 0] =  \
 984                                                         (r * input + out_row[j * components + 0] * anti_input) / 0xff; \
 985                                                 out_row[j * components + 1] =  \
 986                                                         (g * input + out_row[j * components + 1] * anti_input) / 0xff; \
 987                                                 out_row[j * components + 2] =  \
 988                                                         (b * input + out_row[j * components + 2] * anti_input) / 0xff; \
 989                                         } \
 990                                 } \
 991                         } \
 992                 } \
 993         } \
 994 }
 995
 996 void TitleTranslateUnit::process_package(LoadPackage *package)
 997 {
 998         TitleTranslatePackage *pkg = (TitleTranslatePackage*)package;
 999         TitleTranslate *server = (TitleTranslate*)this->server;
1000
1001         switch(plugin->output->get_color_model()) {
1002         case BC_RGB888:     TRANSLATE(unsigned char, 0xff, 3); break;
1003         case BC_RGB_FLOAT:  TRANSLATE(float, 1.0, 3);          break;
1004         case BC_YUV888:     TRANSLATE(unsigned char, 0xff, 3); break;
1005         case BC_RGBA_FLOAT: TRANSLATE(float, 1.0, 4);          break;
1006         case BC_RGBA8888:   TRANSLATE(unsigned char, 0xff, 4); break;
1007         case BC_YUVA8888:   TRANSLATE(unsigned char, 0xff, 4); break;
1008         }
1009 //printf("TitleTranslateUnit::process_package 5\n");
1010 }
1011
1012
1013
1014
1015 TitleTranslate::TitleTranslate(TitleMain *plugin, int cpus)
1016  : LoadServer(cpus, cpus)
1017 {
1018         this->plugin = plugin;
1019         x_table = 0;
1020         y_table = 0;
1021         out_x1 = out_x2 = 0;
1022         out_y1 = out_y2 = 0;
1023         out_x1_int = out_x2_int = 0;
1024         out_y1_int = out_y2_int = 0;
1025         output_w = output_h = 0;
1026 }
1027
1028 TitleTranslate::~TitleTranslate()
1029 {
1030         delete [] x_table;
1031         delete [] y_table;
1032 }
1033
1034 void TitleTranslate::init_packages()
1035 {
1036 // Generate scaling tables
1037         delete [] x_table;  x_table = 0;
1038         delete [] y_table;  y_table = 0;
1039
1040         output_w = plugin->output->get_w();
1041         output_h = plugin->output->get_h();
1042
1043         float x1 = plugin->text_x1 + plugin->extent.x1;
1044         float x2 = plugin->text_x1 + plugin->extent.x2;
1045         TitleTranslateUnit::translation_array_f(x_table, x1, x2, 0,
1046                 plugin->mask_w, plugin->mask_w,
1047                 output_w, out_x1_int, out_x2_int);
1048
1049         float y1 = plugin->text_y1 + plugin->extent.y1;
1050         float y2 = plugin->text_y1 + plugin->extent.y2;
1051         TitleTranslateUnit::translation_array_f(y_table, y1, y2, 0,
1052                 plugin->mask_h, plugin->mask_h,
1053                 output_h, out_y1_int, out_y2_int);
1054
1055 //printf("TitleTranslate::init_packages 1\n");
1056         out_x1 = out_x1_int;  out_x2 = out_x2_int;
1057         out_y1 = out_y1_int;  out_y2 = out_y2_int;
1058
1059         int out_h = out_y2 - out_y1;
1060         int py1 = 0, py2 = 0;
1061         int pkgs = get_total_packages();
1062         for( int i=0; i<pkgs; py1=py2 ) {
1063                 TitleTranslatePackage *pkg = (TitleTranslatePackage*)get_package(i);
1064                 py2 = (++i*out_h) / pkgs;
1065                 pkg->y1 = py1;  pkg->y2 = py2;
1066         }
1067 //printf("TitleTranslate::init_packages 2\n");
1068 }
1069
1070 LoadClient* TitleTranslate::new_client()
1071 {
1072         return new TitleTranslateUnit(plugin, this);
1073 }
1074
1075 LoadPackage* TitleTranslate::new_package()
1076 {
1077         return new TitleTranslatePackage;
1078 }
1079
1080
1081
1082 TitleMain::TitleMain(PluginServer *server)
1083  : PluginVClient(server)
1084 {
1085         text_mask = 0;
1086         outline_mask = 0;
1087         text_mask_stroke = 0;
1088         glyph_engine = 0;
1089         title_engine = 0;
1090         freetype_face = 0;
1091         freetype_library = 0;
1092         char_pos = 0;
1093         row_geom = 0;
1094         row_geom_size = 0;
1095         translate = 0;
1096         outline_engine = 0;
1097         visible_row1 = 0;       visible_row2 = 0;
1098         visible_char1 = 0;      visible_char2 = 0;
1099         text_y1 = text_y2 = text_x1 = 0;
1100         alpha = 0x100;
1101         text_rows = 0;
1102         text_w = 0; text_h = 0;
1103         input = 0;  output = 0;
1104         cpus = PluginClient::smp + 1;
1105         if( cpus > 8 ) cpus = 8;
1106         need_reconfigure = 1;
1107 }
1108
1109 TitleMain::~TitleMain()
1110 {
1111         delete text_mask;
1112         delete outline_mask;
1113         delete text_mask_stroke;
1114         delete [] char_pos;
1115         delete [] row_geom;
1116         clear_glyphs();
1117         delete glyph_engine;
1118         delete title_engine;
1119         if( freetype_face )
1120                 FT_Done_Face(freetype_face);
1121         if( freetype_library )
1122                 FT_Done_FreeType(freetype_library);
1123         delete translate;
1124         delete outline_engine;
1125 }
1126
1127 const char* TitleMain::plugin_title() { return N_("Title"); }
1128 int TitleMain::is_realtime() { return 1; }
1129 int TitleMain::is_synthesis() { return 1; }
1130
1131 NEW_WINDOW_MACRO(TitleMain, TitleWindow);
1132
1133
1134 void TitleMain::build_previews(TitleWindow *gui)
1135 {
1136         ArrayList<BC_FontEntry*>*fonts = gui->get_resources()->fontlist;
1137
1138         for(int font_number = 0; font_number < fonts->size(); font_number++)
1139         {
1140                 BC_FontEntry *font_entry = fonts->get(font_number);
1141 // already have examples
1142                 if(font_entry->image) return;
1143         }
1144
1145 // create example bitmaps
1146         FT_Library freetype_library = 0;        // Freetype library
1147         FT_Face freetype_face = 0;
1148         const char *test_string = "Aa";
1149         char new_path[BCTEXTLEN];
1150         int text_height = gui->get_text_height(LARGEFONT);
1151         int text_color = BC_WindowBase::get_resources()->default_text_color;
1152         int r = (text_color >> 16) & 0xff;
1153         int g = (text_color >> 8) & 0xff;
1154         int b = text_color & 0xff;
1155 // dimensions for each line
1156         int height[fonts->size()];
1157         int ascent[fonts->size()];
1158
1159 // pass 1 gets the extents for all the fonts
1160 // pass 2 draws the image
1161         int total_w = 0;
1162         int total_h = 0;
1163         for(int pass = 0; pass < 2; pass++)
1164         {
1165 //printf("TitleMain::build_previews %d %d %d\n",
1166 //__LINE__,
1167 //text_height,
1168 //total_h);
1169                 for(int font_number = 0; font_number < fonts->size(); font_number++)
1170                 {
1171                         BC_FontEntry *font_entry = fonts->get(font_number);
1172
1173 // test if font of same name has been processed
1174                         int skip = 0;
1175                         for(int i = 0; i < font_number; i++) {
1176                                 if(!strcasecmp(fonts->get(i)->displayname, font_entry->displayname)) {
1177                                         if(pass == 1) {
1178                                                 font_entry->image = fonts->get(i)->image;
1179                                         }
1180                                         skip = 1;
1181                                         break;
1182                                 }
1183                         }
1184
1185                         if(skip) continue;
1186
1187                         int current_x = 0;
1188                         int current_w = 0;
1189                         int current_ascent = 0;
1190                         int current_h = 0;
1191                         if(pass == 1) {
1192                                 font_entry->image = new VFrame;
1193                                 font_entry->image->set_use_shm(0);
1194                                 font_entry->image->reallocate(0, -1, 0, 0, 0,
1195                                         total_w, total_h, BC_RGBA8888, -1);
1196                                 font_entry->image->clear_frame();
1197                         }
1198
1199                         current_x = 0;
1200                         current_w = 0;
1201                         int len = strlen(test_string);
1202                         for(int j = 0; j < len; j++)
1203                         {
1204                                 FT_ULong c = test_string[j];
1205                                 check_char_code_path(freetype_library,
1206                                         font_entry->path,
1207                                         c,
1208                                         (char *)new_path);
1209                                 if( !load_freetype_face(freetype_library,
1210                                         freetype_face, new_path)) {
1211                                         FT_Set_Pixel_Sizes(freetype_face, text_height, 0);
1212
1213                                         if(!FT_Load_Char(freetype_face, c, FT_LOAD_RENDER)) {
1214                                                 if(pass == 0) {
1215                                                         current_w = current_x + freetype_face->glyph->bitmap.width;
1216                                                         if(freetype_face->glyph->bitmap_top > current_ascent)
1217                                                                 current_ascent = freetype_face->glyph->bitmap_top;
1218                                                         if(freetype_face->glyph->bitmap.rows > total_h)
1219                                                                 total_h = freetype_face->glyph->bitmap.rows;
1220                                                         if(freetype_face->glyph->bitmap.rows > current_h)
1221                                                                 current_h = freetype_face->glyph->bitmap.rows;
1222                                                 }
1223                                                 else {
1224 // copy 1 row at a time
1225 // center vertically
1226                                                         int out_y = (total_h - height[font_number]) / 2 +
1227                                                                 ascent[font_number] - freetype_face->glyph->bitmap_top;
1228                                                         for(int in_y = 0;
1229                                                                 in_y < freetype_face->glyph->bitmap.rows &&
1230                                                                         out_y < total_h;
1231                                                                 in_y++, out_y++) {
1232                                                                 unsigned char *out_row = font_entry->image->get_rows()[out_y] +
1233                                                                         current_x * 4;
1234                                                                 unsigned char *in_row = freetype_face->glyph->bitmap.buffer +
1235                                                                         freetype_face->glyph->bitmap.pitch * in_y;
1236
1237                                                                 for(int out_x = 0; out_x < freetype_face->glyph->bitmap.width &&
1238                                                                         out_x < total_w;
1239                                                                         out_x++) {
1240                                                                         *out_row = (*in_row * r +
1241                                                                                 (0xff - *in_row) * *out_row) / 0xff; ++out_row;
1242                                                                         *out_row = (*in_row * g +
1243                                                                                 (0xff - *in_row) * *out_row) / 0xff; ++out_row;
1244                                                                         *out_row = (*in_row * b +
1245                                                                                 (0xff - *in_row) * *out_row) / 0xff; ++out_row;
1246                                                                         *out_row = MAX(*in_row, *out_row);  ++out_row;
1247                                                                         in_row++;
1248                                                                 }
1249                                                         }
1250                                                 }
1251
1252
1253                                                 current_x += freetype_face->glyph->advance.x >> 6;
1254                                         }
1255                                 }
1256                         }
1257
1258                         height[font_number] = current_h;
1259                         ascent[font_number] = current_ascent;
1260                         if(pass == 0 && current_w > total_w) total_w = current_w;
1261
1262                 }
1263         }
1264
1265         if(freetype_library) FT_Done_FreeType(freetype_library);
1266 }
1267
1268
1269
1270 //This checks if char_code is on the selected font, else it changes font to the first compatible //Akirad
1271 int TitleMain::check_char_code_path(FT_Library &freetype_library,
1272         char *path_old,
1273         FT_ULong &char_code,
1274         char *path_new)
1275 {
1276         FT_Face temp_freetype_face;
1277         FcPattern *pat;
1278         FcFontSet *fs;
1279         FcObjectSet *os;
1280         FcChar8 *file, *format;
1281         FcConfig *config;
1282         int i;
1283
1284         FcInit();
1285         config = FcConfigGetCurrent();
1286         FcConfigSetRescanInterval(config, 0);
1287
1288         pat = FcPatternCreate();
1289         os = FcObjectSetBuild ( FC_FILE, FC_FONTFORMAT, (char *) 0);
1290         fs = FcFontList(config, pat, os);
1291         FcPattern *font;
1292         int notfindit = 1;
1293         char tmpstring[BCTEXTLEN];
1294         int limit_to_truetype = 0; //if you want to limit search to truetype put 1
1295         if(!freetype_library) FT_Init_FreeType(&freetype_library);
1296         if(!FT_New_Face(freetype_library,
1297                                         path_old,
1298                                         0,
1299                                         &temp_freetype_face))
1300         {
1301                 FT_Set_Pixel_Sizes(temp_freetype_face, 128, 0);
1302                 int gindex = FT_Get_Char_Index(temp_freetype_face, char_code);
1303                 if((!gindex == 0) && (!char_code != 10))
1304                 {
1305                         strcpy(path_new, path_old);
1306                         notfindit = 0;
1307                 }
1308         }
1309
1310         if(notfindit)
1311         {
1312                 for (i=0; fs && i < fs->nfont; i++)
1313                 {
1314                         font = fs->fonts[i];
1315                         FcPatternGetString(font, FC_FONTFORMAT, 0, &format);
1316                         if((!strcmp((char *)format, "TrueType")) || limit_to_truetype)
1317                         {
1318                                 if(FcPatternGetString(font, FC_FILE, 0, &file) == FcResultMatch)
1319                                 {
1320
1321                                         sprintf(tmpstring, "%s", file);
1322                                         if(!FT_New_Face(freetype_library,
1323                                                                 tmpstring,
1324                                                                 0,
1325                                                                 &temp_freetype_face))
1326                                         {
1327                                                 FT_Set_Pixel_Sizes(temp_freetype_face, 128, 0);
1328                                                 int gindex = FT_Get_Char_Index(temp_freetype_face, char_code);
1329                                                 if((!gindex == 0) && (!char_code != 10))
1330                                                 {
1331                                                         sprintf(path_new, "%s", tmpstring);
1332                                                         notfindit = 0;
1333                                                         goto done;
1334
1335                                                 }
1336                                         }
1337                                 }
1338                         }
1339                 }
1340         }
1341
1342 done:
1343         if(fs) FcFontSetDestroy(fs);
1344         if(temp_freetype_face) FT_Done_Face(temp_freetype_face);
1345         temp_freetype_face = 0;
1346
1347         if(notfindit)
1348         {
1349                 strcpy(path_new, path_old);
1350                 return 1;
1351         }
1352
1353         return 0;
1354 }
1355
1356
1357
1358
1359 int TitleMain::load_freetype_face(FT_Library &freetype_library,
1360         FT_Face &freetype_face,
1361         const char *path)
1362 {
1363 //printf("TitleMain::load_freetype_face 1\n");
1364         if(!freetype_library)
1365                 FT_Init_FreeType(&freetype_library);
1366         if(freetype_face)
1367                 FT_Done_Face(freetype_face);
1368         freetype_face = 0;
1369 //printf("TitleMain::load_freetype_face 2\n");
1370
1371 // Use freetype's internal function for loading font
1372         if(FT_New_Face(freetype_library, path, 0, &freetype_face)) {
1373                 fprintf(stderr, _("TitleMain::load_freetype_face %s failed.\n"), path);
1374                 freetype_face = 0;
1375                 freetype_library = 0;
1376                 return 1;
1377         }
1378         return 0;
1379 }
1380
1381 BC_FontEntry* TitleMain::get_font()
1382 {
1383         int style = 0;
1384         int mask;
1385
1386         style |= (config.style & BC_FONT_ITALIC) ? FL_SLANT_ITALIC : FL_SLANT_ROMAN;
1387         style |= (config.style & BC_FONT_BOLD) ? FL_WEIGHT_BOLD : FL_WEIGHT_NORMAL;
1388
1389         mask = FL_WEIGHT_MASK | FL_SLANT_MASK;
1390
1391         BC_Resources *resources =  BC_WindowBase::get_resources();
1392         return resources->find_fontentry(config.font, style, mask);
1393 }
1394
1395 int TitleMain::get_char_height()
1396 {
1397 // this is baseline to the baseline distance
1398         int result = config.size;
1399         if((config.style & BC_FONT_OUTLINE)) result += (int)ceil(config.stroke_width * 2);
1400         return result;
1401 }
1402
1403 TitleGlyph *TitleMain::get_glyph(FT_ULong char_code)
1404 {
1405         for(int i = 0; i < glyphs.size(); i++) {
1406                 if(glyphs.get(i)->char_code == char_code)
1407                         return glyphs.get(i);
1408         }
1409         return 0;
1410 }
1411
1412 int TitleMain::get_char_width(FT_ULong char_code)
1413 {
1414         if(char_code == '\n') return 0;
1415         TitleGlyph *glyph = get_glyph(char_code);
1416         return !glyph ? 0 : glyph->width;
1417 }
1418
1419 int TitleMain::get_char_advance(FT_ULong current, FT_ULong next)
1420 {
1421         FT_Vector kerning;
1422
1423         if(current == '\n') return 0;
1424         TitleGlyph *current_glyph = get_glyph(current);
1425         int result = !current_glyph ? 0 : current_glyph->advance_x;
1426         TitleGlyph *next_glyph = !next ? 0 : get_glyph(next);
1427         if(next_glyph)
1428                 FT_Get_Kerning(freetype_face,
1429                                 current_glyph->freetype_index,
1430                                 next_glyph->freetype_index,
1431                                 ft_kerning_default,
1432                                 &kerning);
1433         else
1434                 kerning.x = 0;
1435         return result + (kerning.x >> 6);
1436 }
1437
1438 void TitleMain::load_glyphs()
1439 {
1440 // Build table of all glyphs needed
1441         int total_packages = 0;
1442
1443         for(int i = 0; i < config.wlen; i++)
1444         {
1445                 int exists = 0;
1446                 FT_ULong char_code = config.wtext[i];
1447
1448                 for(int j = 0; j < glyphs.total; j++) {
1449                         if(glyphs.values[j]->char_code == char_code) {
1450                                 exists = 1;
1451                                 break;
1452                         }
1453                 }
1454
1455                 if(!exists && char_code != 0) {
1456                         total_packages++;
1457                         TitleGlyph *glyph = new TitleGlyph;
1458                         glyphs.append(glyph);
1459                         glyph->char_code = char_code;
1460                 }
1461         }
1462
1463         if(!glyph_engine)
1464                 glyph_engine = new GlyphEngine(this, cpus);
1465
1466         glyph_engine->set_package_count(total_packages);
1467         glyph_engine->process_packages();
1468 }
1469
1470
1471 void TitleMain::get_total_extents()
1472 {
1473 // Determine extents of total text
1474         int wlen = config.wlen;
1475         char_pos = new char_pos_t[wlen+1];
1476
1477         int pitch = config.line_pitch;
1478         int font_h = get_char_height();
1479         int row = 0;
1480         int row_w = 0, row_h = 0;
1481         int max_char_w = 0, max_char_h = 0;
1482         text_h = text_w = 0;
1483
1484         // unjustified positions, initial bbox
1485         for(int i = 0; i < wlen; i++) {
1486                 char_pos[i].x = row_w;
1487                 char_pos[i].y = text_h;
1488                 char_pos[i].row = row;
1489                 wchar_t wchar = config.wtext[i];
1490                 if( wchar == '\n' ) {
1491                         text_h += pitch ? pitch : row_h > font_h ? row_h : font_h;
1492                         if(row_w > text_w) text_w = row_w;
1493                         row_w = row_h = 0;  ++row;
1494                         continue;
1495                 }
1496                 TitleGlyph *glyph = get_glyph(wchar);
1497                 int char_w = i+1>=wlen ? glyph->width :
1498                         get_char_advance(wchar, config.wtext[i+1]);
1499                 char_pos[i].w = char_w;
1500                 row_w += char_w;
1501                 if( char_w > max_char_w ) max_char_w = char_w;
1502                 int char_h = glyph->top - glyph->bottom;
1503                 if( char_h > max_char_h ) max_char_h = char_h;
1504                 if( char_h > row_h ) row_h = char_h;
1505 //printf("charcode '%c'  %d,%d  glyph bbox %d,%d %d,%d\n",
1506 //  (int)wchar, char_pos[i].x, char_pos[i].y,
1507 //  glyph->left, glyph->top, glyph->right, glyph->bottom);
1508         }
1509         if( wlen > 0 && config.wtext[wlen-1] != '\n' ) {
1510                 text_h += pitch ? pitch : row_h > font_h ? row_h : font_h;
1511                 if(row_w > text_w) text_w = row_w;
1512                 ++row;
1513         }
1514         char_pos[wlen].x = row_w;
1515         char_pos[wlen].y = text_h;
1516         char_pos[wlen].row = row;
1517         char_pos[wlen].w = 0;
1518         text_rows = row;
1519
1520         // justify positions
1521         int row_start = 0, pos = 0;
1522         switch(config.hjustification) {
1523         case JUSTIFY_MID:
1524                 while( row_start < wlen ) {
1525                         while( pos<wlen && config.wtext[pos]!='\n' ) ++pos;
1526                         int ofs = (text_w - char_pos[pos].x) / 2;
1527 //printf("justify_mid ofs=%d\n", ofs);
1528                         while( row_start < pos )
1529                                 char_pos[row_start++].x += ofs;
1530                         ++pos;
1531                 }
1532                 break;
1533         case JUSTIFY_RIGHT:
1534                 while( row_start < wlen ) {
1535                         while( pos<wlen && config.wtext[pos]!='\n' ) ++pos;
1536                         int ofs = text_w - char_pos[pos].x;
1537 //printf("justify_right ofs=%d\n", ofs);
1538                         while( row_start < pos )
1539                                 char_pos[row_start++].x += ofs;
1540                         ++pos;
1541                 }
1542                 break;
1543         case JUSTIFY_LEFT:
1544         default:
1545                 break;
1546         }
1547
1548         if( row_geom_size < text_rows+1 ) {
1549                 delete [] row_geom;   row_geom = 0;
1550         }
1551         if (!row_geom) {
1552                 row_geom_size = text_rows+1;
1553                 row_geom = new RowGeom[row_geom_size];
1554         }
1555
1556         // Determine row extents
1557         struct RowGeom *geom = &row_geom[0];
1558         TitleGlyph *glyph = 0;
1559         geom->x0 = geom->y0 = 0;
1560         geom->x1 = geom->y1 = 0;
1561         geom->x2 = geom->y2 = 0;
1562
1563         // x0,y0 row origin in without kern
1564         // x1,y1 - x2,y2 left baseline relative bbox with kerns
1565         for(int i = 0; i < wlen; i++) {
1566                 int x = char_pos[i].x;
1567                 int y = char_pos[i].y;
1568                 wchar_t wchar = config.wtext[i];
1569                 if( wchar == '\n' ) {
1570                         glyph = 0;  ++geom;
1571                         geom->x0 = geom->y0 = 0;
1572                         geom->x1 = geom->y1 = 0;
1573                         geom->x2 = geom->y2 = 0;
1574                         continue;
1575                 }
1576                 TitleGlyph *gp = get_glyph(wchar);
1577                 if( !gp ) continue;
1578                 if( !glyph ) {
1579                         geom->x0 = x;          geom->y0 = y;
1580                         int dx = x-geom->x0, dy = y-geom->y0 + config.size;
1581                         geom->x1 = dx + gp->left;   geom->y1 = dy - gp->top;
1582                         geom->x2 = dx + gp->right;  geom->y2 = dy - gp->bottom;
1583                 }
1584                 glyph = gp;
1585                 int dx = x-geom->x0, dy = y-geom->y0 + config.size;
1586                 int dx1 = dx + glyph->left;
1587                 int dx2 = dx + glyph->right;
1588                 if( dx1 < geom->x1 ) geom->x1 = dx1;
1589                 if( dx2 > geom->x2 ) geom->x2 = dx2;
1590                 int dy1 = dy - glyph->top;
1591                 int dy2 = dy - glyph->bottom;
1592                 if( dy1 < geom->y1 ) geom->y1 = dy1;
1593                 if( dy2 > geom->y2 ) geom->y2 = dy2;
1594 //printf("charcode '%c'  %d,%d row bbox %d,%d %d,%d %d,%d\n",
1595 //  (int)wchar, x,y, geom->x0,geom->y0, geom->x1,geom->y1, geom->x2,geom->y2);
1596         }
1597         if( wlen > 0 && config.wtext[wlen-1] != '\n' ) {
1598                 ++geom;
1599                 geom->x0 = 0;
1600                 geom->y0 = text_h;
1601                 geom->x1 = geom->y1 = 0;
1602                 geom->x2 = geom->y2 = 0;
1603         }
1604 }
1605
1606 int TitleMain::draw_mask()
1607 {
1608         int old_visible_row1 = visible_row1;
1609         int old_visible_row2 = visible_row2;
1610
1611 // Determine y of visible text
1612         if(config.motion_strategy == BOTTOM_TO_TOP) {
1613 // printf("TitleMain::draw_mask 1 %d %lld %lld %lld\n",
1614 //      config.motion_strategy,
1615 //      get_source_position(),
1616 //      get_source_start(),
1617 //      config.prev_keyframe_position);
1618                 float magnitude = config.pixels_per_second *
1619                         (get_source_position() - config.prev_keyframe_position) /
1620                         PluginVClient::project_frame_rate;
1621                 if(config.loop) {
1622                         int loop_size = text_h + input->get_h();
1623                         magnitude -= (int)(magnitude / loop_size) * loop_size;
1624                 }
1625                 text_y1 = config.y + input->get_h() - magnitude;
1626         }
1627         else
1628         if(config.motion_strategy == TOP_TO_BOTTOM) {
1629                 float magnitude = config.pixels_per_second *
1630                         (get_source_position() - config.prev_keyframe_position) /
1631                         PluginVClient::project_frame_rate;
1632                 if(config.loop)
1633                 {
1634                         int loop_size = text_h + input->get_h();
1635                         magnitude -= (int)(magnitude / loop_size) * loop_size;
1636                 }
1637                 text_y1 = config.y + magnitude;
1638                 text_y1 -= text_h;
1639         }
1640         else if(config.vjustification == JUSTIFY_TOP) {
1641                 text_y1 = config.y;
1642         }
1643         else if(config.vjustification == JUSTIFY_MID) {
1644                 text_y1 = config.y + input->get_h() / 2 - text_h / 2;
1645         }
1646         else if(config.vjustification == JUSTIFY_BOTTOM) {
1647                 text_y1 = config.y + input->get_h() - text_h;
1648         }
1649
1650         text_y2 = text_y1 + text_h + 0.5;
1651
1652 // Determine x of visible text
1653         if(config.motion_strategy == RIGHT_TO_LEFT) {
1654                 float magnitude = config.pixels_per_second *
1655                         (get_source_position() - config.prev_keyframe_position) /
1656                         PluginVClient::project_frame_rate;
1657                 if(config.loop) {
1658                         int loop_size = text_w + input->get_w();
1659                         magnitude -= (int)(magnitude / loop_size) * loop_size;
1660                 }
1661                 text_x1 = config.x + (float)input->get_w() - magnitude;
1662         }
1663         else if(config.motion_strategy == LEFT_TO_RIGHT) {
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)text_w + magnitude;
1672         }
1673         else if(config.hjustification == JUSTIFY_LEFT) {
1674                 text_x1 = config.x;
1675         }
1676         else if(config.hjustification == JUSTIFY_MID) {
1677                 text_x1 = config.x + input->get_w() / 2 - text_w / 2;
1678         }
1679         else if(config.hjustification == JUSTIFY_RIGHT) {
1680                 text_x1 = config.x + input->get_w() - text_w;
1681         }
1682         text_x2 = text_x1 + text_w;
1683
1684         // bottom of this row is visible
1685         visible_row1 = 0;
1686         RowGeom *geom = 0;
1687         while( visible_row1 < text_rows ) {
1688                 geom = &row_geom[visible_row1];
1689                 int y0 = text_y1 + geom->bottom();
1690                 if( y0 > 0 ) break;
1691                 ++visible_row1;
1692         }
1693
1694         // top of next row is not visible
1695         visible_row2 = visible_row1;
1696         while( visible_row2 < text_rows ) {
1697                 geom = &row_geom[visible_row2];
1698                 int y0 = text_y1 + geom->top();
1699                 if( y0 >= input->get_h() ) break;
1700                 ++visible_row2;
1701         }
1702
1703         if( visible_row1 == visible_row2 ) return 1;
1704
1705 //printf("visible rows %d to %d\n", visible_row1, visible_row2);
1706         // Only use visible rows, get bbox including kerns
1707         // text origin, no kerning
1708         geom = &row_geom[visible_row1];
1709         extent.x0 = geom->x0;       extent.y0 = geom->y0;
1710         extent.x1 = geom->left();   extent.y1 = geom->top();
1711         extent.x2 = geom->right();  extent.y2 = geom->bottom();
1712
1713         for( int i=visible_row1; i<visible_row2; ++i ) {
1714                 geom = &row_geom[i];  int v;
1715                 if( (v=geom->left())   < extent.x1 ) extent.x1 = v;
1716                 if( (v=geom->top())    < extent.y1 ) extent.y1 = v;
1717                 if( (v=geom->right())  > extent.x2 ) extent.x2 = v;
1718                 if( (v=geom->bottom()) > extent.y2 ) extent.y2 = v;
1719         }
1720
1721 //printf("exts x0,y0=%d,%d  x1,y1=%d,%d  x2,y2=%d,%d text %f,%f %dx%d\n",
1722 // extent.x0,extent.y0, extent.x1,extent.y1, extent.x2,extent.y2,
1723 // text_x1,text_y1, text_w,text_h);
1724         // Only draw visible chars
1725         visible_char1 = visible_char2 = -1;
1726         int wlen = config.wlen;
1727         for(int i = 0; i < wlen; i++) {
1728                 char_pos_t *pos = char_pos + i;
1729                 if( pos->row < visible_row1 ) continue;
1730                 if( pos->row >= visible_row2 ) continue;
1731                 if(visible_char1 < 0) visible_char1 = i;
1732                 visible_char2 = i;
1733         }
1734         visible_char2++;
1735
1736         extent.x1 -= config.outline_size*2;
1737         extent.y1 -= config.outline_size*2;
1738         extent.x2 += config.dropshadow + config.outline_size*2;
1739         extent.y2 += config.dropshadow + config.outline_size*2;
1740
1741         // Determine mask geometry
1742         mask_w = extent.x2 - extent.x1;
1743         if( mask_w <= 0 ) return 1;
1744         mask_h = extent.y2 - extent.y1;
1745         if( mask_h <= 0 ) return 1;
1746
1747 //printf("TitleMain::draw_mask %d-%d frame %dx%d\n",
1748 //  visible_row1, visible_row2, mask_w,mask_h)
1749         int need_redraw = 0;
1750         if(text_mask && (text_mask->get_w() != mask_w || text_mask->get_h() != mask_h)) {
1751                 delete text_mask;         text_mask = 0;
1752                 delete text_mask_stroke;  text_mask_stroke = 0;
1753         }
1754
1755         if(!text_mask) {
1756 // Always use 8 bit because the glyphs are 8 bit
1757 // Need to set YUV to get clear_frame to set the right chroma.
1758                 int output_model = get_output()->get_color_model();
1759                 int color_model = BC_CModels::is_yuv(output_model) ? BC_YUVA8888 : BC_RGBA8888;
1760                 text_mask = new VFrame;
1761                 text_mask->set_use_shm(0);
1762                 text_mask->reallocate(0, -1, 0, 0, 0, mask_w, mask_h, color_model, -1);
1763                 int drop = !config.dropshadow ? 0 : config.dropshadow;
1764                 int drop_w = mask_w + drop;
1765                 int drop_h = mask_h + drop;
1766                 text_mask_stroke = new VFrame;
1767                 text_mask_stroke->set_use_shm(0);
1768                 text_mask_stroke->reallocate(0, -1, 0, 0, 0, drop_w, drop_h, color_model, -1);
1769                 need_redraw = 1;
1770         }
1771
1772 // Draw on text mask if it has changed
1773         if( need_redraw ||
1774             old_visible_row1 != visible_row1 ||
1775             old_visible_row2 != visible_row2 ) {
1776 //printf("redraw %d to %d   %d,%d  %d,%d - %d,%d\n", visible_char1,visible_char2,
1777 //  extent.x0, extent.y0, extent.x1,extent.y1, extent.x2,extent.y2);
1778
1779                 text_mask->clear_frame();
1780                 text_mask_stroke->clear_frame();
1781 #if 0
1782                 unsigned char *data = text_mask->get_data(); // draw bbox on text_mask
1783                 for( int x=0; x<mask_w; ++x ) data[4*x+3] = 0xff;
1784                 for( int x=0; x<mask_w; ++x ) data[4*((mask_h-1)*mask_w+x)+3] = 0xff;
1785                 for( int y=0; y<mask_h; ++y ) data[4*mask_w*y+3] = 0xff;
1786                 for( int y=0; y<mask_h; ++y ) data[4*(mask_w*y + mask_w-1)+3] = 0xff;
1787 #endif
1788                 if(!title_engine)
1789                         title_engine = new TitleEngine(this, cpus);
1790
1791 // Draw dropshadow first
1792                 if(config.dropshadow) {
1793                         title_engine->do_dropshadow = 1;
1794                         title_engine->set_package_count(visible_char2 - visible_char1);
1795                         title_engine->process_packages();
1796                 }
1797
1798 // Then draw foreground
1799                 title_engine->do_dropshadow = 0;
1800                 title_engine->set_package_count(visible_char2 - visible_char1);
1801                 title_engine->process_packages();
1802
1803 // Convert to text outlines
1804                 if(config.outline_size > 0) {
1805                         if(outline_mask &&
1806                             (text_mask->get_w() != outline_mask->get_w() ||
1807                              text_mask->get_h() != outline_mask->get_h())) {
1808                                 delete outline_mask;  outline_mask = 0;
1809                         }
1810
1811                         if(!outline_mask) {
1812                                 outline_mask = new VFrame;
1813                                 outline_mask->set_use_shm(0);
1814                                 outline_mask->reallocate(0, -1, 0, 0, 0,
1815                                         text_mask->get_w(), text_mask->get_h(),
1816                                         text_mask->get_color_model(), -1);
1817                         }
1818                         if(!outline_engine) outline_engine =
1819                                 new TitleOutlineEngine(this, cpus);
1820                         outline_engine->do_outline();
1821                 }
1822         }
1823
1824         return 0;
1825 }
1826
1827 void TitleMain::overlay_mask()
1828 {
1829
1830 //printf("TitleMain::overlay_mask 1\n");
1831         alpha = 0x100;
1832         if(!EQUIV(config.fade_in, 0))
1833         {
1834                 int fade_len = lroundf(config.fade_in * PluginVClient::project_frame_rate);
1835                 int fade_position = get_source_position() - config.prev_keyframe_position;
1836
1837                 if(fade_position >= 0 && fade_position < fade_len)
1838                 {
1839                         alpha = lroundf(256.0f * fade_position / fade_len);
1840                 }
1841         }
1842         if(!EQUIV(config.fade_out, 0))
1843         {
1844                 int fade_len = lroundf(config.fade_out * PluginVClient::project_frame_rate);
1845                 int fade_position = config.next_keyframe_position - get_source_position();
1846
1847
1848                 if(fade_position >= 0 && fade_position < fade_len)
1849                 {
1850                         alpha = lroundf(256.0f * fade_position / fade_len);
1851                 }
1852         }
1853
1854         if(!translate)
1855                 translate = new TitleTranslate(this, cpus);
1856
1857         if(config.dropshadow)
1858         {
1859                 text_x1 += config.dropshadow;
1860                 if(text_x1 < input->get_w() && text_x1 + text_w > 0)
1861                 {
1862 // Do 2 passes if dropshadow.
1863                         int temp_color = config.color;
1864                         config.color = 0x0;
1865                         translate->run_packages();
1866                         config.color = temp_color;
1867                 }
1868                 text_x1 -= config.dropshadow;
1869         }
1870 //printf("TitleMain::overlay_mask 1\n");
1871
1872         if(text_x1 < input->get_w() && text_x1 + text_w > 0) {
1873                 translate->run_packages();
1874                 if (config.stroke_width >= ZERO && (config.style & BC_FONT_OUTLINE)) {
1875                         int temp_color = config.color;
1876                         VFrame *tmp_text_mask = this->text_mask;
1877                         config.color = config.color_stroke;
1878                         this->text_mask = this->text_mask_stroke;
1879
1880                         translate->run_packages();
1881                         config.color = temp_color;
1882                         this->text_mask = tmp_text_mask;
1883                 }
1884         }
1885 //printf("TitleMain::overlay_mask 200\n");
1886 }
1887
1888 void TitleMain::get_color_components(int *r, int *g, int *b, int *a, int is_outline)
1889 {
1890         int r_in, g_in, b_in, a_in;
1891
1892         if(is_outline)
1893         {
1894                 r_in = (config.outline_color & 0xff0000) >> 16;
1895                 g_in = (config.outline_color & 0xff00) >> 8;
1896                 b_in = config.outline_color & 0xff;
1897                 a_in = config.outline_alpha;
1898         }
1899         else
1900         {
1901                 r_in = (config.color & 0xff0000) >> 16;
1902                 g_in = (config.color & 0xff00) >> 8;
1903                 b_in = config.color & 0xff;
1904                 a_in = config.alpha;
1905         }
1906         *r = r_in;
1907         *g = g_in;
1908         *b = b_in;
1909         *a = a_in;
1910
1911         switch(output->get_color_model())
1912         {
1913                 case BC_YUV888:
1914                         yuv.rgb_to_yuv_8(r_in, g_in, b_in, *r, *g, *b);
1915                         break;
1916                 case BC_YUVA8888:
1917                         yuv.rgb_to_yuv_8(r_in, g_in, b_in, *r, *g, *b);
1918                         break;
1919         }
1920 }
1921
1922 void TitleMain::clear_glyphs()
1923 {
1924 //printf("TitleMain::clear_glyphs 1\n");
1925         glyphs.remove_all_objects();
1926 }
1927
1928 const char* TitleMain::motion_to_text(int motion)
1929 {
1930         switch(motion)
1931         {
1932                 case NO_MOTION: return _("No motion"); break;
1933                 case BOTTOM_TO_TOP: return _("Bottom to top"); break;
1934                 case TOP_TO_BOTTOM: return _("Top to bottom"); break;
1935                 case RIGHT_TO_LEFT: return _("Right to left"); break;
1936                 case LEFT_TO_RIGHT: return _("Left to right"); break;
1937         }
1938         return "";
1939 }
1940
1941 int TitleMain::text_to_motion(const char *text)
1942 {
1943         for(int i = 0; i < TOTAL_PATHS; i++)
1944         {
1945                 if(!strcasecmp(motion_to_text(i), text)) return i;
1946         }
1947         return 0;
1948 }
1949
1950 void TitleMain::reset_render()
1951 {
1952         delete text_mask;          text_mask = 0;
1953         delete glyph_engine;       glyph_engine = 0;
1954         delete [] char_pos;        char_pos = 0;
1955         delete text_mask_stroke;   text_mask_stroke = 0;
1956         delete [] row_geom;        row_geom = 0;
1957         row_geom_size = 0;
1958         visible_row1 = 0;          visible_row2 = 0;
1959         visible_char1 = 0;         visible_char2 = 0;
1960         text_rows = 0;
1961         clear_glyphs();
1962         if(freetype_face) {
1963                 FT_Done_Face(freetype_face);
1964                 freetype_face = 0;
1965         }
1966 }
1967
1968 int TitleMain::init_freetype()
1969 {
1970         if(!freetype_library)
1971                 FT_Init_FreeType(&freetype_library);
1972         if(!freetype_face) {
1973                 BC_FontEntry *font = get_font();
1974                 if(load_freetype_face(freetype_library, freetype_face, font->path)) {
1975                         printf("TitleMain::process_realtime %s: FT_New_Face failed.\n",
1976                                 font->displayname);
1977                         return 1;
1978                 }
1979                 FT_Set_Pixel_Sizes(freetype_face, config.size, 0);
1980         }
1981         return 0;
1982 }
1983
1984 int TitleMain::process_realtime(VFrame *input_ptr, VFrame *output_ptr)
1985 {
1986         int result = 0;
1987         input = input_ptr;
1988         output = output_ptr;
1989
1990         need_reconfigure |= load_configuration();
1991
1992 // Check boundaries
1993         if(config.size <= 0 || config.size >= 2048)
1994                 config.size = 72;
1995         if(config.stroke_width < 0 || config.stroke_width >= 512)
1996                 config.stroke_width = 0.0;
1997         if(!config.wlen)
1998                 return 0;
1999         if(!strlen(config.encoding))
2000                 strcpy(config.encoding, DEFAULT_ENCODING);
2001
2002 // Always synthesize text and redraw it for timecode
2003         if(config.timecode)
2004         {
2005                 int64_t rendered_frame = get_source_position();
2006                 if (get_direction() == PLAY_REVERSE)
2007                         rendered_frame -= 1;
2008
2009                 char text[BCTEXTLEN];
2010                 Units::totext(text,
2011                                 (double)rendered_frame / PluginVClient::project_frame_rate,
2012                                 config.timecode_format,
2013                                 PluginVClient::get_project_samplerate(),
2014                                 PluginVClient::get_project_framerate(),
2015                                 16);
2016                 config.to_wtext(config.encoding, text, strlen(text)+1);
2017                 need_reconfigure = 1;
2018         }
2019
2020 // printf("TitleMain::process_realtime %d need_reconfigure=%d\n",
2021 // __LINE__,
2022 // need_reconfigure);
2023
2024 // Handle reconfiguration
2025         if(need_reconfigure) {
2026                 reset_render();
2027                 result = init_freetype();
2028                 if(!result) {
2029 //PRINT_TRACE
2030                         load_glyphs();
2031                         get_total_extents();
2032                         need_reconfigure = 0;
2033                 }
2034         }
2035
2036         if(!result) {
2037 //PRINT_TRACE
2038 // Determine region of text visible on the output and draw mask
2039                 result = draw_mask();
2040         }
2041
2042
2043 // Overlay mask on output
2044         if(!result) {
2045 //PRINT_TRACE
2046                 overlay_mask();
2047         }
2048
2049         return 0;
2050 }
2051
2052 void TitleMain::update_gui()
2053 {
2054         if(thread)
2055         {
2056                 int reconfigure = load_configuration();
2057                 if(reconfigure)
2058                 {
2059                         TitleWindow *window = (TitleWindow*)thread->window;
2060                         window->lock_window("TitleMain::update_gui");
2061                         window->update();
2062                         window->unlock_window();
2063                         window->color_thread->update_gui(config.color, 0);
2064                         window->unlock_window();
2065                 }
2066         }
2067 }
2068
2069 int TitleMain::load_configuration()
2070 {
2071         KeyFrame *prev_keyframe, *next_keyframe;
2072         prev_keyframe = get_prev_keyframe(get_source_position());
2073         next_keyframe = get_next_keyframe(get_source_position());
2074
2075         TitleConfig old_config, prev_config, next_config;
2076         old_config.copy_from(config);
2077         read_data(prev_keyframe);
2078         prev_config.copy_from(config);
2079         read_data(next_keyframe);
2080         next_config.copy_from(config);
2081
2082         config.prev_keyframe_position = prev_keyframe->position;
2083         config.next_keyframe_position = next_keyframe->position;
2084
2085         // if no previous keyframe exists, it should be start of the plugin, not start of the track
2086         if(config.next_keyframe_position == config.prev_keyframe_position)
2087                 config.next_keyframe_position = get_source_start() + get_total_len();
2088         if (config.prev_keyframe_position == 0)
2089                 config.prev_keyframe_position = get_source_start();
2090 // printf("TitleMain::load_configuration 10 %d %d\n",
2091 // config.prev_keyframe_position,
2092 // config.next_keyframe_position);
2093
2094         config.interpolate(prev_config,
2095                 next_config,
2096                 (next_keyframe->position == prev_keyframe->position) ?
2097                         get_source_position() :
2098                         prev_keyframe->position,
2099                 (next_keyframe->position == prev_keyframe->position) ?
2100                         get_source_position() + 1 :
2101                         next_keyframe->position,
2102                 get_source_position());
2103
2104         if(!config.equivalent(old_config))
2105                 return 1;
2106         return 0;
2107 }
2108
2109
2110 void TitleMain::save_data(KeyFrame *keyframe)
2111 {
2112         FileXML output;
2113
2114         output.set_shared_output(keyframe->get_data(), MESSAGESIZE);
2115         output.tag.set_title("TITLE");
2116         output.tag.set_property("FONT", config.font);
2117         output.tag.set_property("ENCODING", config.encoding);
2118         output.tag.set_property("STYLE", (int64_t)config.style);
2119         output.tag.set_property("SIZE", config.size);
2120         output.tag.set_property("COLOR", config.color);
2121         output.tag.set_property("COLOR_STROKE", config.color_stroke);
2122         output.tag.set_property("STROKE_WIDTH", config.stroke_width);
2123         output.tag.set_property("OUTLINE_COLOR", config.outline_color);
2124         output.tag.set_property("ALPHA", config.alpha);
2125         output.tag.set_property("OUTLINE_ALPHA", config.outline_alpha);
2126         output.tag.set_property("MOTION_STRATEGY", config.motion_strategy);
2127         output.tag.set_property("LOOP", config.loop);
2128         output.tag.set_property("LINE_PITCH", config.line_pitch);
2129         output.tag.set_property("PIXELS_PER_SECOND", config.pixels_per_second);
2130         output.tag.set_property("HJUSTIFICATION", config.hjustification);
2131         output.tag.set_property("VJUSTIFICATION", config.vjustification);
2132         output.tag.set_property("FADE_IN", config.fade_in);
2133         output.tag.set_property("FADE_OUT", config.fade_out);
2134         output.tag.set_property("TITLE_X", config.x);
2135         output.tag.set_property("TITLE_Y", config.y);
2136         output.tag.set_property("DROPSHADOW", config.dropshadow);
2137         output.tag.set_property("OUTLINE_SIZE", config.outline_size);
2138         output.tag.set_property("TIMECODE", config.timecode);
2139         output.tag.set_property("TIMECODEFORMAT", config.timecode_format);
2140         output.tag.set_property("WINDOW_W", config.window_w);
2141         output.tag.set_property("WINDOW_H", config.window_h);
2142         output.append_tag();
2143         output.append_newline();
2144         char text[BCTEXTLEN];
2145         int text_len = BC_Resources::encode(
2146                 BC_Resources::wide_encoding, DEFAULT_ENCODING,
2147                 (char*)config.wtext, config.wlen*sizeof(wchar_t),
2148                 text, sizeof(text));
2149         output.append_text(text, text_len);
2150         output.tag.set_title("/TITLE");
2151         output.append_tag();
2152         output.append_newline();
2153         output.terminate_string();
2154 //printf("TitleMain::save_data 1\n%s\n", output.string);
2155 //printf("TitleMain::save_data 2\n%s\n", config.text);
2156 }
2157
2158 void TitleMain::read_data(KeyFrame *keyframe)
2159 {
2160         FileXML input;
2161
2162         input.set_shared_input(keyframe->get_data(), strlen(keyframe->get_data()));
2163
2164         int result = 0;
2165
2166         config.prev_keyframe_position = keyframe->position;
2167         while(!result)
2168         {
2169                 result = input.read_tag();
2170                 if( result ) break;
2171
2172                 if(input.tag.title_is("TITLE")) {
2173                         input.tag.get_property("FONT", config.font);
2174                         input.tag.get_property("ENCODING", config.encoding);
2175                         config.style = input.tag.get_property("STYLE", (int64_t)config.style);
2176                         config.size = input.tag.get_property("SIZE", config.size);
2177                         config.color = input.tag.get_property("COLOR", config.color);
2178                         config.color_stroke = input.tag.get_property("COLOR_STROKE", config.color_stroke);
2179                         config.stroke_width = input.tag.get_property("STROKE_WIDTH", config.stroke_width);
2180                         config.outline_color = input.tag.get_property("OUTLINE_COLOR", config.outline_color);
2181                         config.alpha = input.tag.get_property("ALPHA", config.alpha);
2182                         config.outline_alpha = input.tag.get_property("OUTLINE_ALPHA", config.outline_alpha);
2183                         config.motion_strategy = input.tag.get_property("MOTION_STRATEGY", config.motion_strategy);
2184                         config.loop = input.tag.get_property("LOOP", config.loop);
2185                         config.line_pitch = input.tag.get_property("LINE_PITCH", config.line_pitch);
2186                         config.pixels_per_second = input.tag.get_property("PIXELS_PER_SECOND", config.pixels_per_second);
2187                         config.hjustification = input.tag.get_property("HJUSTIFICATION", config.hjustification);
2188                         config.vjustification = input.tag.get_property("VJUSTIFICATION", config.vjustification);
2189                         config.fade_in = input.tag.get_property("FADE_IN", config.fade_in);
2190                         config.fade_out = input.tag.get_property("FADE_OUT", config.fade_out);
2191                         config.x = input.tag.get_property("TITLE_X", config.x);
2192                         config.y = input.tag.get_property("TITLE_Y", config.y);
2193                         config.dropshadow = input.tag.get_property("DROPSHADOW", config.dropshadow);
2194                         config.outline_size = input.tag.get_property("OUTLINE_SIZE", config.outline_size);
2195                         config.timecode = input.tag.get_property("TIMECODE", config.timecode);
2196                         input.tag.get_property("TIMECODEFORMAT", config.timecode_format);
2197                         config.window_w = input.tag.get_property("WINDOW_W", config.window_w);
2198                         config.window_h = input.tag.get_property("WINDOW_H", config.window_h);
2199                         const char *text = input.read_text();
2200                         config.to_wtext(config.encoding, text, strlen(text)+1);
2201                 }
2202                 else if(input.tag.title_is("/TITLE")) {
2203                         result = 1;
2204                 }
2205         }
2206 }