modules/demux/webvtt.c

   1 /*****************************************************************************
   2  * webvtt.c: WEBVTT text demuxer (as ISO1446-30 payload)
   3  *****************************************************************************
   4  * Copyright (C) 2017 VideoLabs, VLC authors and VideoLAN
   5  *
   6  * This program is free software; you can redistribute it and/or modify it
   7  * under the terms of the GNU Lesser General Public License as published by
   8  * the Free Software Foundation; either version 2.1 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 Lesser General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU Lesser General Public License
  17  * along with this program; if not, write to the Free Software Foundation,
  18  * Inc., 51 Franklin Street, Fifth Floor, Boston MA 02110-1301, USA.
  19  *****************************************************************************/
  20
  21 /*****************************************************************************
  22  * Preamble
  23  *****************************************************************************/
  24
  25 #ifdef HAVE_CONFIG_H
  26 # include "config.h"
  27 #endif
  28
  29 #include <vlc_common.h>
  30 #include <vlc_demux.h>
  31 #include <vlc_memstream.h>
  32
  33 #include "../codec/webvtt/webvtt.h"
  34
  35 /*****************************************************************************
  36  * Prototypes:
  37  *****************************************************************************/
  38
  39 struct index_entry_s
  40 {
  41     int64_t time;
  42     unsigned active;
  43 };
  44
  45 typedef struct
  46 {
  47     es_out_id_t *es;
  48     bool         b_slave;
  49     bool         b_first_time;
  50     int          i_next_block_flags;
  51     vlc_tick_t   i_next_demux_time;
  52     vlc_tick_t   i_length;
  53     struct
  54     {
  55         void    *p_data;
  56         size_t   i_data;
  57     } regions_headers, styles_headers;
  58
  59     struct
  60     {
  61         webvtt_cue_t *p_array;
  62         size_t  i_alloc;
  63         size_t  i_count;
  64     } cues;
  65
  66     struct
  67     {
  68         struct index_entry_s *p_array;
  69         size_t   i_alloc;
  70         size_t   i_count;
  71         size_t   i_current;
  72     } index;
  73
  74     webvtt_text_parser_t *p_streamparser;
  75 } demux_sys_t;
  76
  77 #define WEBVTT_PREALLOC 64
  78
  79 /*****************************************************************************
  80  *
  81  *****************************************************************************/
  82 static int cue_Compare( const void *a_, const void *b_ )
  83 {
  84     webvtt_cue_t *a = (webvtt_cue_t *)a_;
  85     webvtt_cue_t *b = (webvtt_cue_t *)b_;
  86     if( a->i_start == b->i_start )
  87     {
  88         if( a->i_stop > b->i_stop )
  89             return -1;
  90         else
  91             return ( a->i_stop < b->i_stop ) ? 1 : 0;
  92     }
  93     else return a->i_start < b->i_start ? -1 : 1;
  94 }
  95
  96 static block_t *ConvertWEBVTT( const webvtt_cue_t *p_cue, bool b_continued )
  97 {
  98     struct vlc_memstream stream;
  99
 100     if( vlc_memstream_open( &stream ) )
 101         return NULL;
 102
 103     const size_t paylsize = 8 + strlen( p_cue->psz_text );
 104     const size_t idensize = (p_cue->psz_id) ? 8 + strlen( p_cue->psz_id ) : 0;
 105     const size_t attrsize = (p_cue->psz_attrs) ? 8 + strlen( p_cue->psz_attrs ) : 0;
 106     const size_t vttcsize = 8 + paylsize + attrsize + idensize;
 107
 108     uint8_t vttcbox[8] = { 0, 0, 0, 0, 'v', 't', 't', 'c' };
 109     if( b_continued )
 110         vttcbox[7] = 'x';
 111     SetDWBE( vttcbox, vttcsize );
 112     vlc_memstream_write( &stream, vttcbox, 8 );
 113
 114     if( p_cue->psz_id )
 115     {
 116         uint8_t idenbox[8] = { 0, 0, 0, 0, 'i', 'd', 'e', 'n' };
 117         SetDWBE( idenbox, idensize );
 118         vlc_memstream_write( &stream, idenbox, 8 );
 119         vlc_memstream_write( &stream, p_cue->psz_id, idensize - 8 );
 120     }
 121
 122     if( p_cue->psz_attrs )
 123     {
 124         uint8_t attrbox[8] = { 0, 0, 0, 0, 's', 't', 't', 'g' };
 125         SetDWBE( attrbox, attrsize );
 126         vlc_memstream_write( &stream, attrbox, 8 );
 127         vlc_memstream_write( &stream, p_cue->psz_attrs, attrsize - 8 );
 128     }
 129
 130     uint8_t paylbox[8] = { 0, 0, 0, 0, 'p', 'a', 'y', 'l' };
 131     SetDWBE( paylbox, paylsize );
 132     vlc_memstream_write( &stream, paylbox, 8 );
 133     vlc_memstream_write( &stream, p_cue->psz_text, paylsize - 8 );
 134
 135     if( vlc_memstream_close( &stream ) == VLC_SUCCESS )
 136         return block_heap_Alloc( stream.ptr, stream.length );
 137     else
 138         return NULL;
 139 }
 140
 141 static void memstream_Append( struct vlc_memstream *ms, const char *psz )
 142 {
 143     if( ms->stream != NULL )
 144     {
 145         vlc_memstream_puts( ms, psz );
 146         vlc_memstream_putc( ms, '\n' );
 147     }
 148 }
 149
 150 static void memstream_Grab( struct vlc_memstream *ms, void **pp, size_t *pi )
 151 {
 152     if( ms->stream != NULL && vlc_memstream_close( ms ) == VLC_SUCCESS )
 153     {
 154         if( ms->length == 0 )
 155         {
 156             free( ms->ptr );
 157             ms->ptr = NULL;
 158         }
 159         *pp = ms->ptr;
 160         *pi = ms->length;
 161     }
 162 }
 163
 164 /*****************************************************************************
 165  * Seekable demux Open() parser callbacks
 166  *****************************************************************************/
 167 struct callback_ctx
 168 {
 169     demux_t *p_demux;
 170     struct vlc_memstream regions, styles;
 171     bool b_ordered;
 172 };
 173
 174 static webvtt_cue_t * ParserGetCueHandler( void *priv )
 175 {
 176     struct callback_ctx *ctx = (struct callback_ctx *) priv;
 177     demux_sys_t *p_sys = ctx->p_demux->p_sys;
 178     /* invalid recycled cue */
 179     if( p_sys->cues.i_count &&
 180         p_sys->cues.p_array[p_sys->cues.i_count - 1].psz_text == NULL )
 181     {
 182         return &p_sys->cues.p_array[p_sys->cues.i_count - 1];
 183     }
 184
 185     if( p_sys->cues.i_alloc <= p_sys->cues.i_count &&
 186        (SIZE_MAX / sizeof(webvtt_cue_t)) - WEBVTT_PREALLOC > p_sys->cues.i_alloc )
 187     {
 188         webvtt_cue_t *p_realloc = realloc( p_sys->cues.p_array,
 189                 sizeof(webvtt_cue_t) * ( p_sys->cues.i_alloc + WEBVTT_PREALLOC ) );
 190         if( p_realloc )
 191         {
 192             p_sys->cues.p_array = p_realloc;
 193             p_sys->cues.i_alloc += WEBVTT_PREALLOC;
 194         }
 195     }
 196
 197     if( p_sys->cues.i_alloc > p_sys->cues.i_count )
 198         return &p_sys->cues.p_array[p_sys->cues.i_count++];
 199
 200     return NULL;
 201 }
 202
 203 static void ParserCueDoneHandler( void *priv, webvtt_cue_t *p_cue )
 204 {
 205     struct callback_ctx *ctx = (struct callback_ctx *) priv;
 206     demux_sys_t *p_sys = ctx->p_demux->p_sys;
 207     if( p_cue->psz_text == NULL )
 208     {
 209         webvtt_cue_Clean( p_cue );
 210         webvtt_cue_Init( p_cue );
 211         return;
 212     }
 213     if( p_cue->i_stop > p_sys->i_length )
 214         p_sys->i_length = p_cue->i_stop;
 215     if( p_sys->cues.i_count > 0 &&
 216         p_sys->cues.p_array[p_sys->cues.i_count - 1].i_start != p_cue->i_start )
 217         ctx->b_ordered = false;
 218
 219     /* Store timings */
 220     if( p_sys->index.i_alloc <= p_sys->index.i_count &&
 221        (SIZE_MAX / sizeof(struct index_entry_s)) - WEBVTT_PREALLOC * 2 > p_sys->index.i_alloc )
 222     {
 223         void *p_realloc = realloc( p_sys->index.p_array,
 224                                    sizeof(struct index_entry_s) *
 225                                    ( p_sys->index.i_alloc + WEBVTT_PREALLOC * 2 ) );
 226         if( p_realloc )
 227         {
 228             p_sys->index.p_array = p_realloc;
 229             p_sys->index.i_alloc += WEBVTT_PREALLOC * 2;
 230         }
 231     }
 232     if( p_sys->index.i_alloc > p_sys->index.i_count )
 233     {
 234         p_sys->index.p_array[p_sys->index.i_count].active = 1; /* tmp start tag */
 235         p_sys->index.p_array[p_sys->index.i_count++].time = p_cue->i_start;
 236         p_sys->index.p_array[p_sys->index.i_count].active = 0;
 237         p_sys->index.p_array[p_sys->index.i_count++].time = p_cue->i_stop;
 238     }
 239 }
 240
 241 static void ParserHeaderHandler( void *priv, enum webvtt_header_line_e s,
 242                                  bool b_new, const char *psz_line )
 243 {
 244     VLC_UNUSED(b_new);
 245     struct callback_ctx *ctx = (struct callback_ctx *) priv;
 246     if( s == WEBVTT_HEADER_STYLE )
 247         memstream_Append( &ctx->styles, psz_line );
 248     else if( s == WEBVTT_HEADER_REGION )
 249         memstream_Append( &ctx->regions, psz_line );
 250 }
 251
 252 /*****************************************************************************
 253  * Streamed cues DemuxStream() parser callbacks
 254  *****************************************************************************/
 255
 256 static webvtt_cue_t * StreamParserGetCueHandler( void *priv )
 257 {
 258     VLC_UNUSED(priv);
 259     return malloc( sizeof(webvtt_cue_t) );
 260 }
 261
 262 static void StreamParserCueDoneHandler( void *priv, webvtt_cue_t *p_cue )
 263 {
 264     demux_t *p_demux = (demux_t *) priv;
 265     demux_sys_t *p_sys = p_demux->p_sys;
 266
 267     if( p_cue->psz_text )
 268     {
 269         block_t *p_block = ConvertWEBVTT( p_cue, true );
 270         if( p_block )
 271         {
 272             if ( p_sys->b_first_time )
 273             {
 274                 es_out_SetPCR( p_demux->out, p_cue->i_start + VLC_TICK_0 );
 275                 p_sys->b_first_time = false;
 276             }
 277             p_sys->i_next_demux_time = p_cue->i_start;
 278             p_block->i_dts =
 279                     p_block->i_pts = VLC_TICK_0 + p_cue->i_start;
 280             if( p_cue->i_stop >= 0 && p_cue->i_stop >= p_cue->i_start )
 281                 p_block->i_length = p_cue->i_stop - p_cue->i_start;
 282             es_out_Send( p_demux->out, p_sys->es, p_block );
 283             es_out_SetPCR( p_demux->out, p_cue->i_start + VLC_TICK_0 );
 284         }
 285     }
 286     webvtt_cue_Clean( p_cue );
 287     free( p_cue );
 288 }
 289
 290 /*****************************************************************************
 291  * Demux Index
 292  *****************************************************************************/
 293
 294 static int index_Compare( const void *a_, const void *b_ )
 295 {
 296     struct index_entry_s *a = (struct index_entry_s *) a_;
 297     struct index_entry_s *b = (struct index_entry_s *) b_;
 298     if( a->time == b->time )
 299     {
 300         if( a->active > b->active )
 301             return -1;
 302         else
 303             return b->active - a->active;
 304     }
 305     else return a->time < b->time ? -1 : 1;
 306 }
 307
 308 static size_t getIndexByTime( demux_sys_t *p_sys, vlc_tick_t i_time )
 309 {
 310     for( size_t i=0; i<p_sys->index.i_count; i++ )
 311     {
 312         if( p_sys->index.p_array[i].time >= i_time )
 313             return i;
 314     }
 315     return 0;
 316 }
 317
 318 static void BuildIndex( demux_t *p_demux )
 319 {
 320     demux_sys_t *p_sys = p_demux->p_sys;
 321
 322     /* Order time entries ascending, start time before end time */
 323     qsort( p_sys->index.p_array, p_sys->index.i_count,
 324            sizeof(struct index_entry_s), index_Compare );
 325
 326     /* Build actives count
 327     TIME 3000 count 1
 328     TIME 14500 count 2 (1 overlap)
 329     TIME 16100 count 3 (2 overlaps)
 330     TIME 16100 count 2 (1 overlap.. because there next start == end)
 331     TIME 18000 count 3
 332     TIME 18000 count 2 */
 333     unsigned i_overlaps = 0;
 334     for( size_t i=0; i<p_sys->index.i_count; i++ )
 335     {
 336         if( p_sys->index.p_array[i].active )
 337             p_sys->index.p_array[i].active = ++i_overlaps;
 338         else
 339             p_sys->index.p_array[i].active = --i_overlaps;
 340     }
 341 }
 342
 343 static block_t *demux_From( demux_t *p_demux, vlc_tick_t i_start )
 344 {
 345     demux_sys_t *p_sys = p_demux->p_sys;
 346
 347     block_t *p_list = NULL;
 348     block_t **pp_append = &p_list;
 349     for( size_t i=0; i<p_sys->cues.i_count; i++ )
 350     {
 351         const webvtt_cue_t *p_cue = &p_sys->cues.p_array[i];
 352         if( p_cue->i_start > i_start )
 353         {
 354             break;
 355         }
 356         else if( p_cue->i_start <= i_start && p_cue->i_stop > i_start )
 357         {
 358             *pp_append = ConvertWEBVTT( p_cue, p_sys->index.i_current > 0 );
 359             if( *pp_append )
 360                 pp_append = &((*pp_append)->p_next);
 361         }
 362     }
 363
 364     return ( p_list ) ? block_ChainGather( p_list ) : NULL;
 365 }
 366
 367 static int ReadWEBVTT( demux_t *p_demux )
 368 {
 369     demux_sys_t *p_sys = p_demux->p_sys;
 370
 371     struct callback_ctx ctx;
 372     ctx.p_demux = p_demux;
 373     ctx.b_ordered = true;
 374
 375     webvtt_text_parser_t *p_parser =
 376             webvtt_text_parser_New( &ctx, ParserGetCueHandler,
 377                                           ParserCueDoneHandler,
 378                                           ParserHeaderHandler );
 379     if( p_parser == NULL )
 380         return VLC_EGENERIC;
 381
 382     (void) vlc_memstream_open( &ctx.regions );
 383     (void) vlc_memstream_open( &ctx.styles );
 384
 385     char *psz_line;
 386     while( (psz_line = vlc_stream_ReadLine( p_demux->s )) )
 387         webvtt_text_parser_Feed( p_parser, psz_line );
 388     webvtt_text_parser_Feed( p_parser, NULL );
 389
 390     if( !ctx.b_ordered )
 391         qsort( p_sys->cues.p_array, p_sys->cues.i_count, sizeof(webvtt_cue_t), cue_Compare );
 392
 393     BuildIndex( p_demux );
 394
 395     memstream_Grab( &ctx.regions, &p_sys->regions_headers.p_data,
 396                                   &p_sys->regions_headers.i_data );
 397     memstream_Grab( &ctx.styles, &p_sys->styles_headers.p_data,
 398                                  &p_sys->styles_headers.i_data );
 399
 400     webvtt_text_parser_Delete( p_parser );
 401
 402     return VLC_SUCCESS;
 403 }
 404
 405 static void MakeExtradata( demux_sys_t *p_sys, void **p_extra, size_t *pi_extra )
 406 {
 407     struct vlc_memstream extradata;
 408     if( vlc_memstream_open( &extradata ) )
 409         return;
 410     vlc_memstream_puts( &extradata, "WEBVTT\n\n");
 411     vlc_memstream_write( &extradata, p_sys->regions_headers.p_data,
 412                                      p_sys->regions_headers.i_data );
 413     vlc_memstream_write( &extradata, p_sys->styles_headers.p_data,
 414                                      p_sys->styles_headers.i_data );
 415     memstream_Grab( &extradata, p_extra, pi_extra );
 416 }
 417
 418 /*****************************************************************************
 419  * Control:
 420  *****************************************************************************/
 421 static int Control( demux_t *p_demux, int i_query, va_list args )
 422 {
 423     demux_sys_t *p_sys = p_demux->p_sys;
 424     int64_t *pi64, i64;
 425     double *pf, f;
 426
 427     switch( i_query )
 428     {
 429         case DEMUX_CAN_SEEK:
 430             *va_arg( args, bool * ) = true;
 431             return VLC_SUCCESS;
 432
 433         case DEMUX_GET_LENGTH:
 434             *(va_arg( args, int64_t * )) = p_sys->i_length;
 435             return VLC_SUCCESS;
 436
 437         case DEMUX_GET_TIME:
 438             pi64 = va_arg( args, int64_t * );
 439             *pi64 = p_sys->i_next_demux_time;
 440             return VLC_SUCCESS;
 441
 442         case DEMUX_SET_TIME:
 443             i64 = va_arg( args, int64_t );
 444             {
 445                 p_sys->index.i_current = getIndexByTime( p_sys, i64 );
 446                 p_sys->b_first_time = true;
 447                 p_sys->i_next_demux_time =
 448                         p_sys->index.p_array[p_sys->index.i_current].time;
 449                 p_sys->i_next_block_flags |= BLOCK_FLAG_DISCONTINUITY;
 450                 return VLC_SUCCESS;
 451             }
 452
 453         case DEMUX_GET_POSITION:
 454             pf = va_arg( args, double * );
 455             if( p_sys->index.i_current >= p_sys->index.i_count )
 456             {
 457                 *pf = 1.0;
 458             }
 459             else if( p_sys->index.i_count > 0 )
 460             {
 461                 *pf = (double) p_sys->i_next_demux_time /
 462                       (p_sys->i_length + 0.5);
 463             }
 464             else
 465             {
 466                 *pf = 0.0;
 467             }
 468             return VLC_SUCCESS;
 469
 470         case DEMUX_SET_POSITION:
 471             f = va_arg( args, double );
 472             if( p_sys->cues.i_count )
 473             {
 474                 i64 = f * p_sys->i_length;
 475                 p_sys->index.i_current = getIndexByTime( p_sys, i64 );
 476                 p_sys->b_first_time = true;
 477                 p_sys->i_next_demux_time =
 478                         p_sys->index.p_array[p_sys->index.i_current].time;
 479                 p_sys->i_next_block_flags |= BLOCK_FLAG_DISCONTINUITY;
 480                 return VLC_SUCCESS;
 481             }
 482             break;
 483
 484         case DEMUX_SET_NEXT_DEMUX_TIME:
 485             p_sys->b_slave = true;
 486             p_sys->i_next_demux_time = va_arg( args, vlc_tick_t ) - VLC_TICK_0;
 487             return VLC_SUCCESS;
 488
 489         case DEMUX_CAN_PAUSE:
 490         case DEMUX_SET_PAUSE_STATE:
 491         case DEMUX_CAN_CONTROL_PACE:
 492             return demux_vaControlHelper( p_demux->s, 0, -1, 0, 1, i_query, args );
 493
 494         case DEMUX_GET_PTS_DELAY:
 495         case DEMUX_GET_FPS:
 496         case DEMUX_GET_META:
 497         case DEMUX_GET_ATTACHMENTS:
 498         case DEMUX_GET_TITLE_INFO:
 499         case DEMUX_HAS_UNSUPPORTED_META:
 500         case DEMUX_CAN_RECORD:
 501         default:
 502             break;
 503
 504     }
 505     return VLC_EGENERIC;
 506 }
 507
 508 static int ControlStream( demux_t *p_demux, int i_query, va_list args )
 509 {
 510     demux_sys_t *p_sys = p_demux->p_sys;
 511     int64_t *pi64;
 512
 513     switch( i_query )
 514     {
 515         case DEMUX_GET_TIME:
 516             pi64 = va_arg( args, int64_t * );
 517             if( p_sys->i_next_demux_time != VLC_TICK_INVALID )
 518             {
 519                 *pi64 = p_sys->i_next_demux_time;
 520                 return VLC_SUCCESS;
 521             }
 522         default:
 523             break;
 524     }
 525
 526     return VLC_EGENERIC;
 527 }
 528
 529 /*****************************************************************************
 530  * Demux: Send subtitle to decoder
 531  *****************************************************************************/
 532 static int Demux( demux_t *p_demux )
 533 {
 534     demux_sys_t *p_sys = p_demux->p_sys;
 535
 536     vlc_tick_t i_barrier = p_sys->i_next_demux_time;
 537
 538     while( p_sys->index.i_current < p_sys->index.i_count &&
 539            p_sys->index.p_array[p_sys->index.i_current].time <= i_barrier )
 540     {
 541         /* Find start and end of our interval */
 542         vlc_tick_t i_start_time = p_sys->index.p_array[p_sys->index.i_current].time;
 543         vlc_tick_t i_end_time = i_start_time;
 544         /* use next interval time as end time */
 545         while( ++p_sys->index.i_current < p_sys->index.i_count )
 546         {
 547             if( i_start_time != p_sys->index.p_array[p_sys->index.i_current].time )
 548             {
 549                 i_end_time = p_sys->index.p_array[p_sys->index.i_current].time;
 550                 break;
 551             }
 552         }
 553
 554         block_t *p_block = demux_From( p_demux, i_start_time );
 555         if( p_block )
 556         {
 557             p_block->i_length = i_end_time - i_start_time;
 558             p_block->i_dts = p_block->i_pts = VLC_TICK_0 + i_start_time;
 559
 560             if( p_sys->i_next_block_flags )
 561             {
 562                 p_block->i_flags = p_sys->i_next_block_flags;
 563                 p_sys->i_next_block_flags = 0;
 564             }
 565
 566             if ( !p_sys->b_slave && p_sys->b_first_time )
 567             {
 568                 es_out_SetPCR( p_demux->out, p_block->i_dts );
 569                 p_sys->b_first_time = false;
 570             }
 571
 572             es_out_Send( p_demux->out, p_sys->es, p_block );
 573         }
 574
 575         if( p_sys->index.i_current < p_sys->index.i_count &&
 576             p_sys->index.p_array[p_sys->index.i_current].active > 1 )
 577         {
 578             /* we'll need to clear up overlaps */
 579             p_sys->i_next_block_flags |= BLOCK_FLAG_DISCONTINUITY;
 580         }
 581     }
 582
 583     if ( !p_sys->b_slave )
 584     {
 585         es_out_SetPCR( p_demux->out, VLC_TICK_0 + i_barrier );
 586         p_sys->i_next_demux_time += CLOCK_FREQ;
 587     }
 588
 589     if( p_sys->index.i_current >= p_sys->index.i_count )
 590         return VLC_DEMUXER_EOF;
 591
 592     return VLC_DEMUXER_SUCCESS;
 593 }
 594
 595 static int DemuxStream( demux_t *p_demux )
 596 {
 597     demux_sys_t *p_sys = p_demux->p_sys;
 598
 599     char *psz_line = vlc_stream_ReadLine( p_demux->s );
 600     webvtt_text_parser_Feed( p_sys->p_streamparser, psz_line );
 601
 602     return ( psz_line == NULL ) ? VLC_DEMUXER_EOF : VLC_DEMUXER_SUCCESS;
 603 }
 604
 605 /*****************************************************************************
 606  * Module initializers common
 607  *****************************************************************************/
 608 static int ProbeWEBVTT( demux_t *p_demux )
 609 {
 610     const uint8_t *p_peek;
 611     size_t i_peek = vlc_stream_Peek( p_demux->s, &p_peek, 16 );
 612     if( i_peek < 16 )
 613         return VLC_EGENERIC;
 614
 615     if( !memcmp( p_peek, "\xEF\xBB\xBF", 3 ) )
 616         p_peek += 3;
 617
 618     if( ( memcmp( p_peek, "WEBVTT", 6 ) ||
 619           ( p_peek[6] != '\n' &&
 620             p_peek[6] != ' ' &&
 621             p_peek[6] != '\t' &&
 622            ( p_peek[6] != '\r' || p_peek[7] != '\n' ) )
 623         ) && !p_demux->obj.force )
 624     {
 625         msg_Dbg( p_demux, "subtitle demux discarded" );
 626         return VLC_EGENERIC;
 627     }
 628
 629     return VLC_SUCCESS;
 630 }
 631
 632 /*****************************************************************************
 633  * Module initializers
 634  *****************************************************************************/
 635 int webvtt_OpenDemux ( vlc_object_t *p_this )
 636 {
 637     demux_t        *p_demux = (demux_t*)p_this;
 638     demux_sys_t    *p_sys;
 639
 640     int i_ret = ProbeWEBVTT( p_demux );
 641     if( i_ret != VLC_SUCCESS )
 642         return i_ret;
 643
 644     p_demux->pf_demux = Demux;
 645     p_demux->pf_control = Control;
 646
 647     p_demux->p_sys = p_sys = calloc( 1, sizeof( demux_sys_t ) );
 648     if( p_sys == NULL )
 649         return VLC_ENOMEM;
 650
 651     if( ReadWEBVTT( p_demux ) != VLC_SUCCESS )
 652     {
 653         webvtt_CloseDemux( p_this );
 654         return VLC_EGENERIC;
 655     }
 656
 657     es_format_t fmt;
 658     es_format_Init( &fmt, SPU_ES, VLC_CODEC_WEBVTT );
 659     size_t i_extra = 0;
 660     MakeExtradata( p_sys, &fmt.p_extra, &i_extra );
 661     fmt.i_extra = i_extra;
 662     p_sys->es = es_out_Add( p_demux->out, &fmt );
 663     es_format_Clean( &fmt );
 664     if( p_sys->es == NULL )
 665     {
 666         webvtt_CloseDemux( p_this );
 667         return VLC_EGENERIC;
 668     }
 669
 670     return VLC_SUCCESS;
 671 }
 672
 673 int webvtt_OpenDemuxStream ( vlc_object_t *p_this )
 674 {
 675     demux_t        *p_demux = (demux_t*)p_this;
 676     demux_sys_t    *p_sys;
 677
 678     int i_ret = ProbeWEBVTT( p_demux );
 679     if( i_ret != VLC_SUCCESS )
 680         return i_ret;
 681
 682     p_demux->pf_demux = DemuxStream;
 683     p_demux->pf_control = ControlStream;
 684
 685     p_demux->p_sys = p_sys = calloc( 1, sizeof( demux_sys_t ) );
 686     if( p_sys == NULL )
 687         return VLC_ENOMEM;
 688
 689     p_sys->p_streamparser = webvtt_text_parser_New( p_demux,
 690                                           StreamParserGetCueHandler,
 691                                           StreamParserCueDoneHandler,
 692                                           NULL );
 693     if( !p_sys->p_streamparser )
 694     {
 695         webvtt_CloseDemux( p_this );
 696         return VLC_EGENERIC;
 697     }
 698
 699     es_format_t fmt;
 700     es_format_Init( &fmt, SPU_ES, VLC_CODEC_WEBVTT );
 701     p_sys->es = es_out_Add( p_demux->out, &fmt );
 702     es_format_Clean( &fmt );
 703     if( p_sys->es == NULL )
 704     {
 705         webvtt_CloseDemux( p_this );
 706         return VLC_EGENERIC;
 707     }
 708
 709     return VLC_SUCCESS;
 710 }
 711
 712 /*****************************************************************************
 713  * Close: Close subtitle demux
 714  *****************************************************************************/
 715 void webvtt_CloseDemux( vlc_object_t *p_this )
 716 {
 717     demux_t *p_demux = (demux_t*)p_this;
 718     demux_sys_t *p_sys = p_demux->p_sys;
 719
 720     for( size_t i=0; i< p_sys->cues.i_count; i++ )
 721         webvtt_cue_Clean( &p_sys->cues.p_array[i] );
 722     free( p_sys->cues.p_array );
 723
 724     free( p_sys->index.p_array );
 725
 726     if( p_sys->p_streamparser )
 727     {
 728         webvtt_text_parser_Feed( p_sys->p_streamparser, NULL );
 729         webvtt_text_parser_Delete( p_sys->p_streamparser );
 730     }
 731
 732     free( p_sys );
 733 }