modules/spu/subsdelay.c

   1 /*****************************************************************************
   2  * subsdelay.c : Subsdelay plugin for vlc
   3  *****************************************************************************
   4  * Copyright © 2011 VideoLAN
   5  *
   6  * Authors: Yuval Tze <yuvaltze@gmail.com>
   7  *
   8  * This program is free software; you can redistribute it and/or modify it
   9  * under the terms of the GNU Lesser General Public License as published by
  10  * the Free Software Foundation; either version 2.1 of the License, or
  11  * (at your option) any later version.
  12  *
  13  * This program is distributed in the hope that it will be useful,
  14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
  16  * GNU Lesser General Public License for more details.
  17  *
  18  * You should have received a copy of the GNU Lesser General Public License
  19  * along with this program; if not, write to the Free Software Foundation,
  20  * Inc., 51 Franklin Street, Fifth Floor, Boston MA 02110-1301, USA.
  21  *****************************************************************************/
  22
  23 /*****************************************************************************
  24  * Preamble
  25  *****************************************************************************/
  26
  27 #ifdef HAVE_CONFIG_H
  28 #include "config.h"
  29 #endif
  30
  31 #include <vlc_common.h>
  32 #include <vlc_plugin.h>
  33 #include <vlc_filter.h>
  34 #include <vlc_subpicture.h>
  35 #include <vlc_es.h>
  36 #include <stdlib.h>
  37
  38 /*****************************************************************************
  39  * Local constants
  40  *****************************************************************************/
  41
  42 /* descriptions */
  43
  44 #define SUBSDELAY_HELP N_("Change subtitle delay")
  45
  46 #define MODE_TEXT N_( "Delay calculation mode" )
  47 #define MODE_LONGTEXT N_( \
  48     "Absolute delay - add absolute delay to each subtitle. " \
  49     "Relative to source delay - multiply subtitle delay. " \
  50     "Relative to source content - determine subtitle delay from its content (text)." )
  51
  52 #define FACTOR_TEXT N_( "Calculation factor" )
  53 #define FACTOR_LONGTEXT N_( "Calculation factor. " \
  54     "In Absolute delay mode the factor represents seconds.")
  55
  56 #define OVERLAP_TEXT N_( "Maximum overlapping subtitles" )
  57 #define OVERLAP_LONGTEXT N_( "Maximum number of subtitles allowed at the same time." )
  58
  59 #define MIN_ALPHA_TEXT N_( "Minimum alpha value" )
  60 #define MIN_ALPHA_LONGTEXT N_( \
  61     "Alpha value of the earliest subtitle, where 0 is fully transparent and 255 is fully opaque." )
  62
  63 #define MIN_STOPS_INTERVAL_TEXT N_( "Interval between two disappearances" )
  64 #define MIN_STOPS_INTERVAL_LONGTEXT N_( \
  65     "Minimum time (in milliseconds) that subtitle should stay after its predecessor has disappeared " \
  66     "(subtitle delay will be extended to meet this requirement)." )
  67
  68 #define MIN_STOP_START_INTERVAL_TEXT N_( "Interval between disappearance and appearance" )
  69 #define MIN_STOP_START_INTERVAL_LONGTEXT N_( \
  70     "Minimum time (in milliseconds) between subtitle disappearance and newer subtitle appearance " \
  71     "(earlier subtitle delay will be extended to fill the gap)." )
  72
  73 #define MIN_START_STOP_INTERVAL_TEXT N_( "Interval between appearance and disappearance" )
  74 #define MIN_START_STOP_INTERVAL_LONGTEXT N_( \
  75     "Minimum time (in milliseconds) that subtitle should stay after newer subtitle has appeared " \
  76     "(earlier subtitle delay will be shortened to avoid the overlap)." )
  77
  78 static const int pi_mode_values[] = { 0, 1, 2 };
  79 static const char * const ppsz_mode_descriptions[] = { N_( "Absolute delay" ), N_( "Relative to source delay" ), N_(
  80         "Relative to source content" ) };
  81
  82 /* parameters */
  83
  84 #define CFG_PREFIX "subsdelay-"
  85
  86 #define CFG_MODE                    CFG_PREFIX "mode"
  87 #define CFG_FACTOR                  CFG_PREFIX "factor"
  88 #define CFG_OVERLAP                 CFG_PREFIX "overlap"
  89
  90 #define CFG_MIN_ALPHA               CFG_PREFIX "min-alpha"
  91 #define CFG_MIN_STOPS_INTERVAL      CFG_PREFIX "min-stops"
  92 #define CFG_MIN_STOP_START_INTERVAL CFG_PREFIX "min-stop-start"
  93 #define CFG_MIN_START_STOP_INTERVAL CFG_PREFIX "min-start-stop"
  94
  95
  96 /* max subtitles handled on the heap */
  97 #define SUBSDELAY_MAX_ENTRIES 16
  98
  99 #define SUBSDELAY_MODE_ABSOLUTE                0
 100 #define SUBSDELAY_MODE_RELATIVE_SOURCE_DELAY   1
 101 #define SUBSDELAY_MODE_RELATIVE_SOURCE_CONTENT 2
 102
 103
 104 /*****************************************************************************
 105  * subsdelay_heap_entry_t: Heap entry
 106  *****************************************************************************/
 107
 108 typedef struct subsdelay_heap_entry_t subsdelay_heap_entry_t;
 109
 110 struct subsdelay_heap_entry_t
 111 {
 112     subpicture_t *p_subpic; /* local subtitle */
 113
 114     subpicture_t *p_source; /* subtitle source */
 115
 116     filter_t *p_filter; /* assigned subsdelay filter */
 117
 118     subsdelay_heap_entry_t *p_next; /* next entry */
 119
 120     bool b_update_stop; /* new stop value should be calculated */
 121
 122     bool b_update_ephemer; /* actual stop value is unknown */
 123
 124     bool b_update_position; /* subtitle position should be updated */
 125
 126     bool b_check_empty; /* subtitle content should be checked */
 127
 128     vlc_tick_t i_new_stop; /* new stop value */
 129
 130     /* last region data*/
 131
 132     int i_last_region_x;
 133
 134     int i_last_region_y;
 135
 136     int i_last_region_align;
 137
 138     bool b_last_region_saved;
 139 };
 140
 141 /*****************************************************************************
 142  * subsdelay_heap_t: Heap
 143  *****************************************************************************/
 144
 145 typedef struct
 146 {
 147     vlc_mutex_t lock; /* heap global lock */
 148
 149     subsdelay_heap_entry_t *p_list[SUBSDELAY_MAX_ENTRIES]; /* subtitles entries array */
 150
 151     subsdelay_heap_entry_t *p_head; /* subtitles entries linked list */
 152
 153     int i_count; /* subtitles count */
 154
 155 } subsdelay_heap_t;
 156
 157
 158
 159 /*****************************************************************************
 160 * filter_sys_t: Subsdelay filter descriptor
 161  *****************************************************************************/
 162
 163 typedef struct
 164 {
 165     int i_mode; /* delay calculation mode */
 166
 167     float f_factor; /* calculation factor */
 168
 169     int i_overlap; /* max overlap */
 170
 171     int i_min_alpha; /* oldest subtitle alpha value */
 172
 173     vlc_tick_t i_min_stops_interval;
 174
 175     vlc_tick_t i_min_stop_start_interval;
 176
 177     vlc_tick_t i_min_start_stop_interval;
 178
 179     subsdelay_heap_t heap; /* subpictures list */
 180 } filter_sys_t;
 181
 182
 183 /*****************************************************************************
 184  * Filter functions
 185  *****************************************************************************/
 186
 187 static int SubsdelayCreate( filter_t * );
 188
 189 static void SubsdelayDestroy( filter_t * );
 190
 191 static subpicture_t * SubsdelayFilter( filter_t *p_filter, subpicture_t* p_subpic );
 192
 193 static int SubsdelayCallback( vlc_object_t *p_this, char const *psz_var, vlc_value_t oldval, vlc_value_t newval,
 194         void *p_data );
 195
 196 /*****************************************************************************
 197  * Helper functions
 198  *****************************************************************************/
 199
 200 static void SubsdelayEnforceDelayRules( filter_t *p_filter );
 201
 202 static vlc_tick_t SubsdelayEstimateDelay( filter_t *p_filter, subsdelay_heap_entry_t *p_entry );
 203
 204 static void SubsdelayRecalculateDelays( filter_t *p_filter );
 205
 206 static int SubsdelayCalculateAlpha( filter_t *p_filter, int i_overlapping, int i_source_alpha );
 207
 208 static int SubsdelayGetTextRank( char *psz_text );
 209
 210 static bool SubsdelayIsTextEmpty( const text_segment_t* p_segment );
 211
 212 /*****************************************************************************
 213  * Subpicture functions
 214  *****************************************************************************/
 215
 216 static int SubpicValidateWrapper( subpicture_t *p_subpic, bool has_src_changed, const video_format_t *p_fmt_src,
 217                                   bool has_dst_changed, const video_format_t *p_fmt_dst, vlc_tick_t i_ts );
 218
 219 static void SubpicUpdateWrapper( subpicture_t *p_subpic, const video_format_t *p_fmt_src,
 220                                   const video_format_t *p_fmt_dst, vlc_tick_t i_ts );
 221
 222 static void SubpicDestroyWrapper( subpicture_t *p_subpic );
 223
 224 static void SubpicLocalUpdate( subpicture_t* p_subpic, vlc_tick_t i_ts );
 225
 226 static bool SubpicIsEmpty( subpicture_t* p_subpic );
 227
 228 static subpicture_t *SubpicClone( subpicture_t *p_source, subpicture_updater_t *updater );
 229
 230 static void SubpicDestroyClone( subpicture_t *p_subpic );
 231
 232 /*****************************************************************************
 233  * Heap functions
 234  *****************************************************************************/
 235
 236 static void SubsdelayHeapInit( subsdelay_heap_t *p_heap );
 237
 238 static void SubsdelayHeapDestroy( subsdelay_heap_t *p_heap );
 239
 240 static subsdelay_heap_entry_t *SubsdelayHeapPush( subsdelay_heap_t *p_heap, subpicture_t *p_subpic, filter_t *p_filter );
 241
 242 static void SubsdelayHeapRemove( subsdelay_heap_t *p_heap, subsdelay_heap_entry_t *p_entry );
 243
 244 static void SubsdelayRebuildList( subsdelay_heap_t *p_heap );
 245
 246 static void SubsdelayHeapLock( subsdelay_heap_t *p_heap );
 247
 248 static void SubsdelayHeapUnlock( subsdelay_heap_t *p_heap );
 249
 250 static subsdelay_heap_entry_t * SubsdelayEntryCreate( subpicture_t *p_subpic, filter_t *p_filter );
 251
 252 static void SubsdelayEntryDestroy( subsdelay_heap_entry_t *p_entry );
 253
 254 /* heap / entries special functionality */
 255
 256 static int SubsdelayHeapCountOverlap( subsdelay_heap_t *p_heap, subsdelay_heap_entry_t *p_entry, vlc_tick_t i_date );
 257
 258 static void SubsdelayEntryNewStopValueUpdated( subsdelay_heap_entry_t *p_entry );
 259
 260 /*****************************************************************************
 261  * Module descriptor
 262  *****************************************************************************/
 263
 264 vlc_module_begin()
 265         set_shortname( N_("Subsdelay") )
 266         set_description( N_("Subtitle delay") )
 267         set_help( SUBSDELAY_HELP )
 268         set_callback_sub_filter( SubsdelayCreate )
 269         set_category( CAT_VIDEO )
 270         set_subcategory( SUBCAT_VIDEO_SUBPIC )
 271
 272         add_integer( CFG_MODE, 1, MODE_TEXT, MODE_LONGTEXT, false )
 273         change_integer_list( pi_mode_values, ppsz_mode_descriptions )
 274
 275         add_float_with_range( CFG_FACTOR, 2, 0, 20, FACTOR_TEXT, FACTOR_LONGTEXT, false )
 276
 277         add_integer_with_range( CFG_OVERLAP, 3, 1, 4, OVERLAP_TEXT, OVERLAP_LONGTEXT, false )
 278
 279         add_integer_with_range( CFG_MIN_ALPHA, 70, 0, 255, MIN_ALPHA_TEXT, MIN_ALPHA_LONGTEXT, false )
 280
 281         set_section( N_("Overlap fix"), NULL )
 282
 283         add_integer( CFG_MIN_STOPS_INTERVAL, 1000, MIN_STOPS_INTERVAL_TEXT, MIN_STOPS_INTERVAL_LONGTEXT, false )
 284
 285         add_integer( CFG_MIN_START_STOP_INTERVAL, 1000, MIN_START_STOP_INTERVAL_TEXT,
 286                      MIN_START_STOP_INTERVAL_LONGTEXT, false )
 287
 288         add_integer( CFG_MIN_STOP_START_INTERVAL, 1000, MIN_STOP_START_INTERVAL_TEXT,
 289                      MIN_STOP_START_INTERVAL_LONGTEXT, false )
 290
 291     vlc_module_end ()
 292
 293 static const char * const ppsz_filter_options[] = { "mode", "factor", "overlap", NULL };
 294
 295 static const struct vlc_filter_operations filter_ops = {
 296     .filter_sub = SubsdelayFilter, .close = SubsdelayDestroy,
 297 };
 298
 299 /*****************************************************************************
 300  * SubsdelayCreate: Create subsdelay filter
 301  *****************************************************************************/
 302 static int SubsdelayCreate( filter_t *p_filter )
 303 {
 304     filter_sys_t *p_sys;
 305
 306     /* allocate structure */
 307     p_sys = (filter_sys_t*) malloc( sizeof(filter_sys_t) );
 308
 309     if( !p_sys )
 310     {
 311         return VLC_ENOMEM;
 312     }
 313
 314     /* init parameters */
 315
 316     p_sys->i_mode = var_CreateGetIntegerCommand( p_filter, CFG_MODE );
 317     var_AddCallback( p_filter, CFG_MODE, SubsdelayCallback, p_sys );
 318
 319     p_sys->f_factor = var_CreateGetFloatCommand( p_filter, CFG_FACTOR );
 320     var_AddCallback( p_filter, CFG_FACTOR, SubsdelayCallback, p_sys );
 321
 322     p_sys->i_overlap = var_CreateGetIntegerCommand( p_filter, CFG_OVERLAP );
 323     var_AddCallback( p_filter, CFG_OVERLAP, SubsdelayCallback, p_sys );
 324
 325     p_sys->i_min_alpha = var_CreateGetIntegerCommand( p_filter, CFG_MIN_ALPHA );
 326     var_AddCallback( p_filter, CFG_MIN_ALPHA, SubsdelayCallback, p_sys );
 327
 328     p_sys->i_min_stops_interval
 329             = VLC_TICK_FROM_MS( var_CreateGetIntegerCommand( p_filter, CFG_MIN_STOPS_INTERVAL ) );
 330     var_AddCallback( p_filter, CFG_MIN_STOPS_INTERVAL, SubsdelayCallback, p_sys );
 331
 332     p_sys->i_min_stop_start_interval
 333             = VLC_TICK_FROM_MS( var_CreateGetIntegerCommand( p_filter, CFG_MIN_STOP_START_INTERVAL ) );
 334     var_AddCallback( p_filter, CFG_MIN_STOP_START_INTERVAL, SubsdelayCallback, p_sys );
 335
 336     p_sys->i_min_start_stop_interval
 337             = VLC_TICK_FROM_MS( var_CreateGetIntegerCommand( p_filter, CFG_MIN_START_STOP_INTERVAL ) );
 338     var_AddCallback( p_filter, CFG_MIN_START_STOP_INTERVAL, SubsdelayCallback, p_sys );
 339
 340     p_filter->p_sys = p_sys;
 341     p_filter->ops = &filter_ops;
 342
 343     config_ChainParse( p_filter, CFG_PREFIX, ppsz_filter_options, p_filter->p_cfg );
 344
 345     SubsdelayHeapInit( &p_sys->heap );
 346
 347     return VLC_SUCCESS;
 348 }
 349
 350 /*****************************************************************************
 351  * SubsdelayDestroy: Destroy subsdelay filter
 352  *****************************************************************************/
 353 static void SubsdelayDestroy( filter_t *p_filter )
 354 {
 355     filter_sys_t *p_sys = p_filter->p_sys;
 356
 357     SubsdelayHeapDestroy( &p_sys->heap );
 358
 359     /* destroy parameters */
 360
 361     var_DelCallback( p_filter, CFG_MODE, SubsdelayCallback, p_sys );
 362     var_Destroy( p_filter, CFG_MODE );
 363
 364     var_DelCallback( p_filter, CFG_FACTOR, SubsdelayCallback, p_sys );
 365     var_Destroy( p_filter, CFG_FACTOR );
 366
 367     var_DelCallback( p_filter, CFG_OVERLAP, SubsdelayCallback, p_sys );
 368     var_Destroy( p_filter, CFG_OVERLAP );
 369
 370     var_DelCallback( p_filter, CFG_MIN_ALPHA, SubsdelayCallback, p_sys );
 371     var_Destroy( p_filter, CFG_MIN_ALPHA );
 372
 373     var_DelCallback( p_filter, CFG_MIN_STOPS_INTERVAL, SubsdelayCallback, p_sys );
 374     var_Destroy( p_filter, CFG_MIN_STOPS_INTERVAL );
 375
 376     var_DelCallback( p_filter, CFG_MIN_STOP_START_INTERVAL, SubsdelayCallback, p_sys );
 377     var_Destroy( p_filter, CFG_MIN_STOP_START_INTERVAL );
 378
 379     var_DelCallback( p_filter, CFG_MIN_START_STOP_INTERVAL, SubsdelayCallback, p_sys );
 380     var_Destroy( p_filter, CFG_MIN_START_STOP_INTERVAL );
 381
 382     free( p_sys );
 383 }
 384
 385 /*****************************************************************************
 386  * SubsdelayFilter: Filter new subpicture
 387  *****************************************************************************/
 388 static subpicture_t * SubsdelayFilter( filter_t *p_filter, subpicture_t* p_subpic )
 389 {
 390     subsdelay_heap_t *p_heap;
 391     subsdelay_heap_entry_t *p_entry;
 392
 393     if( !p_subpic->b_subtitle )
 394     {
 395         return p_subpic;
 396     }
 397
 398     if( SubpicIsEmpty( p_subpic ) )
 399     {
 400         /* empty subtitles usually helps terminate ephemer subtitles, but this filter calculates the stop value anyway,
 401            so this subtitle can be dropped */
 402
 403         subpicture_Delete( p_subpic );
 404
 405         return NULL;
 406     }
 407
 408     filter_sys_t *p_sys = p_filter->p_sys;
 409     p_heap = &p_sys->heap;
 410
 411     /* add subpicture to the heap */
 412
 413     SubsdelayHeapLock( p_heap );
 414
 415     p_entry = SubsdelayHeapPush( p_heap, p_subpic, p_filter );
 416     if( !p_entry )
 417     {
 418         SubsdelayHeapUnlock( p_heap );
 419
 420         msg_Err(p_filter, "Can't add subpicture to the heap");
 421
 422         return p_subpic;
 423     }
 424
 425     p_subpic = p_entry->p_subpic; /* get the local subpic */
 426
 427     if( p_subpic->b_ephemer )
 428     {
 429         /* set a relativly long delay in hope that the next subtitle
 430            will arrive in this time and the real delay could be determined */
 431
 432         p_subpic->i_stop = p_subpic->i_start + VLC_TICK_FROM_SEC(20); /* start + 20 sec */
 433         p_subpic->b_ephemer = false;
 434     }
 435
 436
 437     SubsdelayEnforceDelayRules( p_filter );
 438
 439     SubsdelayHeapUnlock( p_heap );
 440
 441     return p_subpic;
 442 }
 443
 444 /*****************************************************************************
 445  * SubsdelayCallback: Subsdelay parameters callback
 446  *****************************************************************************/
 447 static int SubsdelayCallback( vlc_object_t *p_this, char const *psz_var, vlc_value_t oldval, vlc_value_t newval,
 448         void *p_data )
 449 {
 450     filter_sys_t *p_sys = (filter_sys_t *) p_data;
 451
 452     VLC_UNUSED( oldval );
 453
 454     SubsdelayHeapLock( &p_sys->heap );
 455
 456     if( !strcmp( psz_var, CFG_MODE ) )
 457     {
 458         p_sys->i_mode = newval.i_int;
 459     }
 460     else if( !strcmp( psz_var, CFG_FACTOR ) )
 461     {
 462         p_sys->f_factor = newval.f_float;
 463     }
 464     else if( !strcmp( psz_var, CFG_OVERLAP ) )
 465     {
 466         p_sys->i_overlap = newval.i_int;
 467     }
 468     else if( !strcmp( psz_var, CFG_MIN_ALPHA ) )
 469     {
 470         p_sys->i_min_alpha = newval.i_int;
 471     }
 472     else if( !strcmp( psz_var, CFG_MIN_STOPS_INTERVAL ) )
 473     {
 474         p_sys->i_min_stops_interval = VLC_TICK_FROM_MS( newval.i_int );
 475     }
 476     else if( !strcmp( psz_var, CFG_MIN_STOP_START_INTERVAL ) )
 477     {
 478         p_sys->i_min_stop_start_interval = VLC_TICK_FROM_MS( newval.i_int );
 479     }
 480     else if( !strcmp( psz_var, CFG_MIN_START_STOP_INTERVAL ) )
 481     {
 482         p_sys->i_min_start_stop_interval = VLC_TICK_FROM_MS( newval.i_int );
 483     }
 484     else
 485     {
 486         vlc_assert_unreachable();
 487     }
 488
 489     SubsdelayRecalculateDelays( (filter_t *) p_this );
 490
 491     SubsdelayHeapUnlock( &p_sys->heap );
 492     return VLC_SUCCESS;
 493 }
 494
 495 /*****************************************************************************
 496  * SubsdelayHeapInit: Initialize heap
 497  *****************************************************************************/
 498 static void SubsdelayHeapInit( subsdelay_heap_t *p_heap )
 499 {
 500     p_heap->i_count = 0;
 501     p_heap->p_head = NULL;
 502
 503     vlc_mutex_init( &p_heap->lock );
 504 }
 505
 506 /*****************************************************************************
 507  * SubsdelayHeapDestroy: Destroy the heap and remove its entries
 508  *****************************************************************************/
 509 static void SubsdelayHeapDestroy( subsdelay_heap_t *p_heap )
 510 {
 511     SubsdelayHeapLock( p_heap );
 512
 513     for( subsdelay_heap_entry_t *p_entry = p_heap->p_head;
 514          p_entry != NULL; p_entry = p_entry->p_next )
 515     {
 516         p_entry->p_subpic->i_stop = p_entry->p_source->i_stop;
 517
 518         p_entry->p_filter = NULL;
 519     }
 520
 521     SubsdelayHeapUnlock( p_heap );
 522 }
 523
 524 /*****************************************************************************
 525  * SubsdelayHeapPush: Add new subpicture to the heap
 526  *****************************************************************************/
 527 static subsdelay_heap_entry_t *SubsdelayHeapPush( subsdelay_heap_t *p_heap, subpicture_t *p_subpic, filter_t *p_filter )
 528 {
 529     subsdelay_heap_entry_t *p_last, *p_new_entry;
 530
 531     if( p_heap->i_count >= SUBSDELAY_MAX_ENTRIES )
 532     {
 533         return NULL; /* the heap is full */
 534     }
 535
 536     p_new_entry = SubsdelayEntryCreate( p_subpic, p_filter );
 537
 538     if( !p_new_entry )
 539     {
 540         return NULL;
 541     }
 542
 543
 544     p_last = NULL;
 545
 546     for( subsdelay_heap_entry_t *p_entry = p_heap->p_head; p_entry != NULL;
 547          p_entry = p_entry->p_next )
 548     {
 549         if( p_entry->p_source->i_start > p_subpic->i_start )
 550         {
 551             /* the new entry should be inserted before p_entry */
 552             break;
 553         }
 554
 555         p_last = p_entry;
 556     }
 557
 558     if( p_last )
 559     {
 560         p_new_entry->p_next = p_last->p_next;
 561         p_last->p_next = p_new_entry;
 562
 563
 564         if( p_last->b_update_ephemer )
 565         {
 566             /* the correct stop value can be determined */
 567
 568             p_last->p_source->i_stop = p_new_entry->p_source->i_start;
 569             p_last->b_update_ephemer = false;
 570         }
 571     }
 572     else
 573     {
 574         p_new_entry->p_next = p_heap->p_head;
 575         p_heap->p_head = p_new_entry;
 576     }
 577
 578
 579     /* rebuild list */
 580
 581     SubsdelayRebuildList( p_heap );
 582
 583     return p_new_entry;
 584 }
 585
 586 /*****************************************************************************
 587  * SubsdelayHeapRemove: Remove entry
 588  *****************************************************************************/
 589 static void SubsdelayHeapRemove( subsdelay_heap_t *p_heap, subsdelay_heap_entry_t *p_entry )
 590 {
 591     subsdelay_heap_entry_t *p_prev;
 592
 593     p_prev = NULL;
 594
 595     for( subsdelay_heap_entry_t *p_curr = p_heap->p_head; p_curr != NULL;
 596          p_curr = p_curr->p_next )
 597     {
 598         if( p_curr == p_entry )
 599         {
 600             break;
 601         }
 602
 603         p_prev = p_curr;
 604     }
 605
 606     if( p_prev )
 607     {
 608         p_prev->p_next = p_entry->p_next;
 609     }
 610     else
 611     {
 612         p_heap->p_head = p_entry->p_next;
 613     }
 614
 615     p_entry->p_filter = NULL;
 616
 617     SubsdelayRebuildList( p_heap );
 618 }
 619
 620
 621 static void SubsdelayRebuildList( subsdelay_heap_t *p_heap )
 622 {
 623     int i_index;
 624
 625     i_index = 0;
 626     for( subsdelay_heap_entry_t *p_curr = p_heap->p_head; p_curr != NULL;
 627          p_curr = p_curr->p_next )
 628     {
 629         p_heap->p_list[i_index] = p_curr;
 630         i_index++;
 631     }
 632
 633     p_heap->i_count = i_index;
 634 }
 635
 636 /*****************************************************************************
 637  * SubsdelayHeapLock: Lock the heap
 638  *****************************************************************************/
 639 static void SubsdelayHeapLock( subsdelay_heap_t *p_heap )
 640 {
 641     vlc_mutex_lock( &p_heap->lock );
 642 }
 643
 644 /*****************************************************************************
 645  * SubsdelayHeapUnlock: Unlock the heap
 646  *****************************************************************************/
 647 static void SubsdelayHeapUnlock( subsdelay_heap_t *p_heap )
 648 {
 649     vlc_mutex_unlock( &p_heap->lock );
 650 }
 651
 652
 653 /*****************************************************************************
 654  * SubsdelayHeapCreateEntry: Create new entry
 655  *****************************************************************************/
 656 static subsdelay_heap_entry_t * SubsdelayEntryCreate( subpicture_t *p_source, filter_t *p_filter )
 657 {
 658     subsdelay_heap_entry_t *p_entry;
 659
 660     subpicture_t *p_new_subpic;
 661
 662     subpicture_updater_t updater;
 663
 664     /* allocate structure */
 665
 666     p_entry = (subsdelay_heap_entry_t *) malloc( sizeof( subsdelay_heap_entry_t ) );
 667
 668     if( !p_entry )
 669     {
 670         return NULL;
 671     }
 672
 673     /* initialize local updater */
 674
 675     updater.p_sys = p_entry;
 676     updater.pf_validate = SubpicValidateWrapper;
 677     updater.pf_update = SubpicUpdateWrapper;
 678     updater.pf_destroy = SubpicDestroyWrapper;
 679
 680     /* create new subpic */
 681
 682     p_new_subpic = SubpicClone( p_source,  &updater );
 683
 684     if( !p_new_subpic )
 685     {
 686         free( p_entry );
 687         return NULL;
 688     }
 689
 690     /* initialize entry */
 691
 692     p_entry->p_subpic = p_new_subpic;
 693     p_entry->p_source = p_source;
 694     p_entry->p_filter = p_filter;
 695     p_entry->p_next = NULL;
 696     p_entry->b_update_stop = true;
 697     p_entry->b_update_ephemer = p_source->b_ephemer;
 698     p_entry->b_update_position = true;
 699     p_entry->b_check_empty = true;
 700     p_entry->i_new_stop = p_source->i_stop;
 701     p_entry->b_last_region_saved = false;
 702     p_entry->i_last_region_x = 0;
 703     p_entry->i_last_region_y = 0;
 704     p_entry->i_last_region_align = 0;
 705
 706     return p_entry;
 707 }
 708
 709 /*****************************************************************************
 710  * SubsdelayEntryDestroy: Destroy entry
 711  *****************************************************************************/
 712 static void SubsdelayEntryDestroy( subsdelay_heap_entry_t *p_entry )
 713 {
 714     SubpicDestroyClone( p_entry->p_source );
 715     free( p_entry );
 716 }
 717
 718 /*****************************************************************************
 719  * SubsdelayHeapCountOverlap: Count overlapping subtitles at a given time
 720  *****************************************************************************/
 721 static int SubsdelayHeapCountOverlap( subsdelay_heap_t *p_heap, subsdelay_heap_entry_t *p_entry, vlc_tick_t i_date )
 722 {
 723     int i_overlaps;
 724
 725     VLC_UNUSED( p_heap );
 726
 727     i_overlaps = 0;
 728
 729     for( subsdelay_heap_entry_t *p_curr = p_entry->p_next; p_curr != NULL;
 730          p_curr = p_curr->p_next )
 731     {
 732         if( p_curr->p_source->i_start > i_date )
 733         {
 734             break;
 735         }
 736
 737         if( !p_curr->b_check_empty ) /* subtitle was checked, and it's not empty */
 738         {
 739             i_overlaps++;
 740         }
 741     }
 742
 743     return i_overlaps;
 744 }
 745
 746 /*****************************************************************************
 747  * SubsdelayEntryNewStopValueUpdated: Update source stop value after the new
 748  *     stop value was changed
 749  *****************************************************************************/
 750 static void SubsdelayEntryNewStopValueUpdated( subsdelay_heap_entry_t *p_entry )
 751 {
 752     if( !p_entry->b_update_stop )
 753     {
 754         p_entry->p_subpic->i_stop = p_entry->i_new_stop - VLC_TICK_FROM_MS(100); /* 0.1 sec less */
 755     }
 756 }
 757
 758 /*****************************************************************************
 759  * SubsdelayEnforceDelayRules: Update subtitles delay after adding new
 760  *     subtitle or changing subtitle stop value
 761  *****************************************************************************/
 762 static void SubsdelayEnforceDelayRules( filter_t *p_filter )
 763 {
 764     subsdelay_heap_entry_t ** p_list;
 765     int i_count, i_overlap;
 766     vlc_tick_t i_offset;
 767     vlc_tick_t i_min_stops_interval;
 768     vlc_tick_t i_min_stop_start_interval;
 769     vlc_tick_t i_min_start_stop_interval;
 770
 771     filter_sys_t *p_sys = p_filter->p_sys;
 772
 773     p_list = p_sys->heap.p_list;
 774     i_count = p_sys->heap.i_count;
 775
 776     i_overlap = p_sys->i_overlap;
 777     i_min_stops_interval = p_sys->i_min_stops_interval;
 778     i_min_stop_start_interval = p_sys->i_min_stop_start_interval;
 779     i_min_start_stop_interval = p_sys->i_min_start_stop_interval;
 780
 781     /* step 1 - enforce min stops interval rule (extend delays) */
 782
 783     /* look for:
 784     [subtitle 1 ..............]
 785            [subtitle 2 ..............]
 786                               |<-MinStopsInterval->|
 787
 788      * and extend newer subtitle:
 789     [subtitle 1 ..............]
 790            [subtitle 2 ............................]
 791                               |<-MinStopsInterval->|
 792     */
 793
 794     for( int i = 0; i < i_count - 1; i++ )
 795     {
 796         p_list[i + 1]->i_new_stop = __MAX( p_list[i + 1]->i_new_stop,
 797                 p_list[i]->i_new_stop + i_min_stops_interval );
 798     }
 799
 800     /* step 2 - enforce min stop start interval rule (extend delays) */
 801
 802     /* look for:
 803     [subtitle 1 .........]
 804                                    [subtitle 2 ....]
 805           |<-MinStopStartInterval->|
 806
 807      * and fill the gap:
 808     [subtitle 1 ..................]
 809                                    [subtitle 2 ....]
 810           |<-MinStopStartInterval->|
 811     */
 812
 813     for( int i = 0; i < i_count; i++ )
 814     {
 815         for( int j = i + 1; j < __MIN( i_count, i + 1 + i_overlap ); j++ )
 816         {
 817             i_offset = p_list[j]->p_source->i_start - p_list[i]->i_new_stop;
 818
 819             if( i_offset <= 0 )
 820             {
 821                 continue;
 822             }
 823
 824             if( i_offset < i_min_stop_start_interval )
 825             {
 826                 p_list[i]->i_new_stop = p_list[j]->p_source->i_start;
 827             }
 828
 829             break;
 830         }
 831     }
 832
 833     /* step 3 - enforce min start stop interval rule (shorten delays) */
 834
 835     /* look for:
 836     [subtitle 1 ............]
 837                     [subtitle 2 ....................]
 838                     |<-MinStartStopInterval->|
 839
 840      * and remove the overlapping part:
 841     [subtitle 1 ...]
 842                     [subtitle 2 ....................]
 843                     |<-MinStartStopInterval->|
 844     */
 845
 846
 847     for( int i = 0; i < i_count; i++ )
 848     {
 849         for( int j = i + 1; j < __MIN( i_count, i + 1 + i_overlap ); j++ )
 850         {
 851             i_offset = p_list[i]->i_new_stop - p_list[j]->p_source->i_start;
 852
 853             if( i_offset <= 0 )
 854             {
 855                 break;
 856             }
 857
 858             if( i_offset < i_min_start_stop_interval )
 859             {
 860                 p_list[i]->i_new_stop = p_list[j]->p_source->i_start;
 861                 break;
 862             }
 863         }
 864     }
 865
 866     /* step 4 - enforce max overlapping rule (shorten delays)*/
 867
 868     /* look for: (overlap = 2)
 869     [subtitle 1 ..............]
 870              [subtitle 2 ..............]
 871                       [subtitle 3 ..............]
 872
 873
 874      * and cut older subtitle:
 875     [subtitle 1 .....]
 876              [subtitle 2 ..............]
 877                       [subtitle 3 ..............]
 878     */
 879
 880     for( int i = 0; i < i_count - i_overlap; i++ )
 881     {
 882         p_list[i]->i_new_stop = __MIN(p_list[i]->i_new_stop, p_list[i + i_overlap]->p_source->i_start);
 883     }
 884
 885     /* finally - update all */
 886
 887     for( int i = 0; i < i_count; i++ )
 888     {
 889         SubsdelayEntryNewStopValueUpdated( p_list[i] );
 890     }
 891 }
 892
 893 /*****************************************************************************
 894  * SubsdelayRecalculateDelays: Recalculate subtitles delay after changing
 895  *     one of the filter's parameters
 896  *****************************************************************************/
 897 static void SubsdelayRecalculateDelays( filter_t *p_filter )
 898 {
 899     filter_sys_t *p_sys = p_filter->p_sys;
 900     for( subsdelay_heap_entry_t *p_curr = p_sys->heap.p_head;
 901          p_curr != NULL; p_curr = p_curr->p_next )
 902     {
 903         if( !p_curr->b_update_ephemer )
 904         {
 905             p_curr->i_new_stop = p_curr->p_source->i_start + SubsdelayEstimateDelay( p_filter, p_curr );
 906             p_curr->b_update_stop = false;
 907         }
 908     }
 909
 910     SubsdelayEnforceDelayRules( p_filter );
 911 }
 912
 913 /*****************************************************************************
 914  * SubpicValidateWrapper: Subpicture validate callback wrapper
 915  *****************************************************************************/
 916 static int SubpicValidateWrapper( subpicture_t *p_subpic, bool has_src_changed, const video_format_t *p_fmt_src,
 917                                   bool has_dst_changed, const video_format_t *p_fmt_dst, vlc_tick_t i_ts )
 918 {
 919     subsdelay_heap_entry_t *p_entry;
 920     vlc_tick_t i_new_ts;
 921     int i_result = VLC_SUCCESS;
 922
 923     p_entry = p_subpic->updater.p_sys;
 924     if( !p_entry )
 925     {
 926         return VLC_SUCCESS;
 927     }
 928
 929     /* call source validate */
 930     if( p_entry->p_source->updater.pf_validate )
 931     {
 932         i_new_ts = p_entry->p_source->i_start +
 933                    ( (double)( p_entry->p_source->i_stop - p_entry->p_source->i_start ) * ( i_ts - p_entry->p_source->i_start ) ) /
 934                    ( p_entry->i_new_stop - p_entry->p_source->i_start );
 935
 936         i_result = p_entry->p_source->updater.pf_validate( p_entry->p_source, has_src_changed, p_fmt_src,
 937                                                         has_dst_changed, p_fmt_dst, i_new_ts );
 938     }
 939
 940
 941     p_entry->b_last_region_saved = false;
 942
 943     if( p_subpic->p_region )
 944     {
 945         /* save copy */
 946         p_entry->i_last_region_x = p_subpic->p_region->i_x;
 947         p_entry->i_last_region_y = p_subpic->p_region->i_y;
 948         p_entry->i_last_region_align = p_subpic->p_region->i_align;
 949
 950         p_entry->b_last_region_saved = true;
 951     }
 952
 953     if( !i_result )
 954     {
 955         /* subpic update isn't necessary, so local update should be called here */
 956         SubpicLocalUpdate( p_subpic, i_ts );
 957     }
 958
 959     return i_result;
 960 }
 961
 962 /*****************************************************************************
 963  * SubpicUpdateWrapper: Subpicture update callback wrapper
 964  *****************************************************************************/
 965 static void SubpicUpdateWrapper( subpicture_t *p_subpic, const video_format_t *p_fmt_src,
 966                                   const video_format_t *p_fmt_dst, vlc_tick_t i_ts )
 967 {
 968     subsdelay_heap_entry_t *p_entry;
 969     vlc_tick_t i_new_ts;
 970
 971     p_entry = p_subpic->updater.p_sys;
 972     if( !p_entry )
 973     {
 974         return;
 975     }
 976
 977     /* call source update */
 978     if( p_entry->p_source->updater.pf_update )
 979     {
 980         i_new_ts = p_entry->p_source->i_start +
 981                    ( (double)( p_entry->p_source->i_stop - p_entry->p_source->i_start ) * ( i_ts - p_entry->p_source->i_start ) ) /
 982                    ( p_entry->i_new_stop - p_entry->p_source->i_start );
 983
 984         p_entry->p_source->p_region = p_entry->p_subpic->p_region;
 985
 986         p_entry->p_source->updater.pf_update( p_entry->p_source, p_fmt_src, p_fmt_dst, i_new_ts );
 987
 988         p_entry->p_subpic->p_region = p_entry->p_source->p_region;
 989     }
 990
 991     SubpicLocalUpdate( p_subpic, i_ts );
 992 }
 993
 994 /*****************************************************************************
 995  * SubpicDestroyCallback: Subpicture destroy callback
 996  *****************************************************************************/
 997 static void SubpicDestroyWrapper( subpicture_t *p_subpic )
 998 {
 999     subsdelay_heap_entry_t *p_entry;
1000     subsdelay_heap_t *p_heap;
1001
1002     p_entry = p_subpic->updater.p_sys;
1003
1004     if( !p_entry )
1005     {
1006         return;
1007     }
1008
1009     if( p_entry->p_filter )
1010     {
1011         filter_sys_t *p_sys = p_entry->p_filter->p_sys;
1012         p_heap = &p_sys->heap;
1013
1014         SubsdelayHeapLock( p_heap );
1015         SubsdelayHeapRemove( p_heap, p_entry );
1016         SubsdelayHeapUnlock( p_heap );
1017     }
1018
1019     SubsdelayEntryDestroy( p_entry );
1020 }
1021
1022 /*****************************************************************************
1023  * SubpicLocalUpdate: rewrite some of the subpicture parameters
1024  *****************************************************************************/
1025 static void SubpicLocalUpdate( subpicture_t* p_subpic, vlc_tick_t i_ts )
1026 {
1027     subsdelay_heap_entry_t *p_entry;
1028     subsdelay_heap_t *p_heap;
1029     filter_t *p_filter;
1030
1031     int i_overlapping;
1032
1033     p_entry = p_subpic->updater.p_sys;
1034     if( !p_entry || !p_entry->p_filter )
1035     {
1036         return;
1037     }
1038
1039     p_filter = p_entry->p_filter;
1040     filter_sys_t *p_sys = p_filter->p_sys;
1041     p_heap = &p_sys->heap;
1042
1043     SubsdelayHeapLock( p_heap );
1044
1045     if( p_entry->b_check_empty && p_subpic->p_region )
1046     {
1047         //FIXME: What if there is more than one segment?
1048         if( SubsdelayIsTextEmpty( p_subpic->p_region->p_text ) )
1049         {
1050             /* remove empty subtitle */
1051
1052             p_subpic->b_ephemer = false;
1053             p_subpic->i_stop = p_subpic->i_start;
1054
1055             SubsdelayHeapRemove( p_heap, p_entry );
1056
1057             SubsdelayHeapUnlock( p_heap );
1058
1059             return;
1060         }
1061
1062         p_entry->b_check_empty = false;
1063     }
1064
1065     if( p_entry->b_update_stop && !p_entry->b_update_ephemer )
1066     {
1067         p_entry->i_new_stop = p_entry->p_source->i_start + SubsdelayEstimateDelay( p_filter, p_entry );
1068         p_entry->b_update_stop = false;
1069
1070         SubsdelayEnforceDelayRules( p_filter );
1071     }
1072
1073     i_overlapping = SubsdelayHeapCountOverlap( p_heap, p_entry, i_ts );
1074
1075     p_subpic->i_alpha = SubsdelayCalculateAlpha( p_filter, i_overlapping, p_entry->p_source->i_alpha );
1076
1077     if( p_entry->b_update_position )
1078     {
1079         p_subpic->b_absolute = false;
1080
1081         if( p_subpic->p_region )
1082         {
1083             p_subpic->p_region->i_x = 0;
1084             p_subpic->p_region->i_y = 10;
1085             p_subpic->p_region->i_align = ( p_subpic->p_region->i_align & ( ~SUBPICTURE_ALIGN_MASK ) )
1086                     | SUBPICTURE_ALIGN_BOTTOM;
1087         }
1088
1089         p_entry->b_update_position = false;
1090     }
1091     else if( p_entry->b_last_region_saved )
1092     {
1093         p_subpic->b_absolute = true;
1094
1095         if( p_subpic->p_region )
1096         {
1097             p_subpic->p_region->i_x = p_entry->i_last_region_x;
1098             p_subpic->p_region->i_y = p_entry->i_last_region_y;
1099             p_subpic->p_region->i_align = p_entry->i_last_region_align;
1100         }
1101     }
1102
1103     SubsdelayHeapUnlock( p_heap );
1104 }
1105
1106 /*****************************************************************************
1107  * SubpicIsEmpty: subpic region contains empty string
1108  *****************************************************************************/
1109 static bool SubpicIsEmpty( subpicture_t* p_subpic )
1110 {
1111     return ( p_subpic->p_region && ( SubsdelayIsTextEmpty( p_subpic->p_region->p_text ) ) );
1112 }
1113
1114 /*****************************************************************************
1115  * SubpicClone: Clone subpicture (shallow copy)
1116  *****************************************************************************/
1117 static subpicture_t *SubpicClone( subpicture_t *p_source, subpicture_updater_t *updater )
1118 {
1119     subpicture_t *p_subpic;
1120     subpicture_updater_t subpic_updater;
1121     subpicture_private_t *p_subpic_private;
1122
1123     p_subpic = subpicture_New( updater );
1124
1125     if( !p_subpic )
1126     {
1127         return NULL;
1128     }
1129
1130     /* save private members */
1131     subpic_updater = p_subpic->updater;
1132     p_subpic_private = p_subpic->p_private;
1133
1134     /* copy the entire struct */
1135     memcpy( p_subpic, p_source, sizeof( subpicture_t ) );
1136
1137     /* restore private members */
1138     p_subpic->updater = subpic_updater;
1139     p_subpic->p_private = p_subpic_private;
1140
1141     return p_subpic;
1142 }
1143
1144 /*****************************************************************************
1145  * SubpicDestroyClone: destroy cloned subpicture (shared references will not
1146  *     be destroyed)
1147  *****************************************************************************/
1148 static void SubpicDestroyClone( subpicture_t *p_subpic )
1149 {
1150     p_subpic->p_region = NULL; /* don't destroy region */
1151     subpicture_Delete( p_subpic );
1152 }
1153
1154 /*****************************************************************************
1155  * SubsdelayEstimateDelay: Calculate new subtitle delay according to its
1156  *     content and the calculation mode
1157  *****************************************************************************/
1158 static vlc_tick_t SubsdelayEstimateDelay( filter_t *p_filter, subsdelay_heap_entry_t *p_entry )
1159 {
1160     int i_mode;
1161     int i_rank;
1162
1163     filter_sys_t *p_sys = p_filter->p_sys;
1164
1165     i_mode = p_sys->i_mode;
1166
1167     if( i_mode == SUBSDELAY_MODE_ABSOLUTE )
1168     {
1169         return ( p_entry->p_source->i_stop - p_entry->p_source->i_start + vlc_tick_from_sec( p_sys->f_factor ) );
1170     }
1171
1172     if( i_mode == SUBSDELAY_MODE_RELATIVE_SOURCE_CONTENT )
1173     {
1174         if( p_entry->p_subpic && p_entry->p_subpic->p_region && ( p_entry->p_subpic->p_region->p_text ) )
1175         {
1176             //FIXME: We only use a single segment here
1177             i_rank = SubsdelayGetTextRank( p_entry->p_subpic->p_region->p_text->psz_text );
1178
1179             return vlc_tick_from_sec( p_sys->f_factor * i_rank );
1180         }
1181
1182         /* content is unavailable, calculation mode should be based on source delay */
1183         i_mode = SUBSDELAY_MODE_RELATIVE_SOURCE_DELAY;
1184     }
1185
1186     if( likely(i_mode == SUBSDELAY_MODE_RELATIVE_SOURCE_DELAY) )
1187     {
1188         return (vlc_tick_t)( p_sys->f_factor * ( p_entry->p_source->i_stop - p_entry->p_source->i_start ) );
1189     }
1190
1191     return VLC_TICK_FROM_SEC(10); /* 10 sec */
1192 }
1193
1194 /*****************************************************************************
1195  * SubsdelayCalculateAlpha: Calculate subtitle alpha according to source alpha
1196  *     value and number of overlapping subtitles
1197  *****************************************************************************/
1198 static int SubsdelayCalculateAlpha( filter_t *p_filter, int i_overlapping, int i_source_alpha )
1199 {
1200     int i_new_alpha;
1201     int i_min_alpha;
1202
1203     filter_sys_t *p_sys = p_filter->p_sys;
1204
1205     i_min_alpha = p_sys->i_min_alpha;
1206
1207     if( i_overlapping > p_sys->i_overlap - 1)
1208     {
1209         i_overlapping = p_sys->i_overlap - 1;
1210     }
1211
1212     switch ( p_sys->i_overlap )
1213     {
1214     case 1:
1215         i_new_alpha = 255;
1216         break;
1217
1218     case 2:
1219         i_new_alpha = 255 - i_overlapping * ( 255 - i_min_alpha );
1220         break;
1221
1222     case 3:
1223         i_new_alpha = 255 - i_overlapping * ( 255 - i_min_alpha ) / 2;
1224         break;
1225
1226     default:
1227         i_new_alpha = 255 - i_overlapping * ( 255 - i_min_alpha ) / 3;
1228         break;
1229     }
1230
1231     return ( i_source_alpha * i_new_alpha ) / 255;
1232 }
1233
1234 /*****************************************************************************
1235  * SubsdelayGetWordRank: Calculate single word rank according to its length
1236  *****************************************************************************/
1237 static int SubsdelayGetWordRank( int i_length )
1238 {
1239     /* p_rank[0] = p_rank[1] = p_rank[2] = 300;
1240     for( i = 3; i < 20; i++ ) p_rank[i] = (int) ( 1.1 * p_rank[i - 1] ); */
1241
1242     static const int p_rank[20] = { 300, 300, 300, 330, 363, 399, 438, 481, 529, 581,
1243                                     639, 702, 772, 849, 933, 1026, 1128, 1240, 1364, 1500 };
1244
1245     if( i_length < 1 )
1246     {
1247         return 0;
1248     }
1249
1250     if( i_length > 20 )
1251     {
1252         i_length = 20;
1253     }
1254
1255     return p_rank[i_length - 1];
1256 }
1257
1258 /*****************************************************************************
1259  * SubsdelayGetTextRank: Calculate text rank
1260  *****************************************************************************/
1261 static int SubsdelayGetTextRank( char *psz_text )
1262 {
1263     bool b_skip_esc;
1264     bool b_skip_tag;
1265     char c;
1266
1267     int i, i_word_length, i_rank;
1268
1269     i = 0;
1270     i_word_length = 0;
1271     i_rank = 0;
1272
1273     b_skip_esc = false;
1274     b_skip_tag = false;
1275
1276     while ( psz_text[i] != '\0' )
1277     {
1278         c = psz_text[i];
1279         i++;
1280
1281         if( c == '\\' && !b_skip_esc )
1282         {
1283             b_skip_esc = true;
1284             continue;
1285         }
1286
1287         if( psz_text[i] == '<' )
1288         {
1289             b_skip_tag = true;
1290             continue;
1291         }
1292
1293         if( !b_skip_esc && !b_skip_tag )
1294         {
1295             if( c == ' ' || c == ',' || c == '.' || c == '-' || c == '?' || c == '!' ) /* common delimiters */
1296             {
1297                 if( i_word_length > 0 )
1298                 {
1299                     i_rank += SubsdelayGetWordRank( i_word_length );
1300                 }
1301
1302                 i_word_length = 0;
1303             }
1304             else
1305             {
1306                 i_word_length++;
1307             }
1308         }
1309
1310         b_skip_esc = false;
1311
1312         if( c == '>' )
1313         {
1314             b_skip_tag = false;
1315         }
1316
1317     }
1318
1319     if( i_word_length > 0 )
1320     {
1321         i_rank += SubsdelayGetWordRank( i_word_length );
1322     }
1323
1324     return i_rank;
1325 }
1326
1327 /*****************************************************************************
1328  * SubsdelayIsTextEmpty: Check if the text contains spaces only
1329  *****************************************************************************/
1330 static bool SubsdelayIsTextEmpty( const text_segment_t *p_segment )
1331 {
1332     while ( p_segment )
1333     {
1334         if ( strlen( p_segment->psz_text ) > 0 )
1335         {
1336             size_t offset = strspn( p_segment->psz_text, " " );
1337             if ( p_segment->psz_text[offset] )
1338                 return false;
1339         }
1340         p_segment = p_segment->p_next;
1341     }
1342
1343     return true;
1344 }