9caf71a611bd04046234eeca22f4e8e84bbb9820
[vlc.git] / modules / demux / util / sub.c
1 /*****************************************************************************
2  * sub.c
3  *****************************************************************************
4  * Copyright (C) 1999-2001 VideoLAN
5  * $Id: sub.c,v 1.20 2003/07/27 23:58:32 fenrir Exp $
6  *
7  * Authors: Laurent Aimar <fenrir@via.ecp.fr>
8  *
9  * This program is free software; you can redistribute it and/or modify
10  * it under the terms of the GNU General Public License as published by
11  * the Free Software Foundation; either version 2 of the License, or
12  * (at your option) any later version.
13  *
14  * This program is distributed in the hope that it will be useful,
15  * but WITHOUT ANY WARRANTY; without even the implied warranty of
16  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
17  * GNU General Public License for more details.
18  *
19  * You should have received a copy of the GNU General Public License
20  * along with this program; if not, write to the Free Software
21  * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111, USA.
22  *****************************************************************************/
23
24 /*****************************************************************************
25  * Preamble
26  *****************************************************************************/
27 #include <stdlib.h>
28 #include <string.h>
29 #include <errno.h>
30 #include <sys/types.h>
31
32 #include <vlc/vlc.h>
33 #include <vlc/input.h>
34 #include "vlc_video.h"
35
36 #include "sub.h"
37
38
39 static int  Open ( vlc_object_t *p_this );
40
41 static int  sub_open ( subtitle_demux_t *p_sub,
42                        input_thread_t  *p_input,
43                        char  *psz_name,
44                        mtime_t i_microsecperframe );
45 static int  sub_demux( subtitle_demux_t *p_sub, mtime_t i_maxdate );
46 static int  sub_seek ( subtitle_demux_t *p_sub, mtime_t i_date );
47 static void sub_close( subtitle_demux_t *p_sub );
48
49 static void sub_fix( subtitle_demux_t *p_sub );
50
51 static char *ppsz_sub_type[] = { "microdvd", "subrip", "ssa1", "ssa2-4", "vplayer", "sami", NULL };
52
53
54 /*****************************************************************************
55  * Module descriptor
56  *****************************************************************************/
57 #define SUB_DELAY_LONGTEXT \
58     "Delay subtitles (in 1/10s)"
59 #define SUB_FPS_LONGTEXT \
60     "Override frames per second. " \
61     "It will only work with MicroDVD subtitles."
62 #define SUB_TYPE_LONGTEXT \
63     "One from \"microdvd\", \"subrip\", \"ssa1\", \"ssa2-4\", \"vplayer\" " \
64     "\"sami\" (nothing for autodetection, it should always work)."
65
66 vlc_module_begin();
67     set_description( _("Text subtitles demux") );
68     set_capability( "subtitle demux", 12 );
69     add_category_hint( "Subtitles", NULL, VLC_TRUE );
70         add_file( "sub-file", NULL, NULL,
71                   "Subtitles file name", "Subtitles file name", VLC_TRUE );
72         add_float( "sub-fps", 0.0, NULL,
73                    "Frames per second",
74                    SUB_FPS_LONGTEXT, VLC_TRUE );
75         add_integer( "sub-delay", 0, NULL,
76                      "Delay subtitles (in 1/10s)",
77                      SUB_DELAY_LONGTEXT, VLC_TRUE );
78         add_string_from_list( "sub-type", NULL, ppsz_sub_type, NULL,
79                               "subtitles type",
80                               SUB_TYPE_LONGTEXT, VLC_TRUE );
81     set_callbacks( Open, NULL );
82 vlc_module_end();
83
84 /*****************************************************************************
85  * Module initializer
86  *****************************************************************************/
87 static int Open ( vlc_object_t *p_this )
88 {
89     subtitle_demux_t *p_sub = (subtitle_demux_t*)p_this;
90
91     p_sub->pf_open  = sub_open;
92     p_sub->pf_demux = sub_demux;
93     p_sub->pf_seek  = sub_seek;
94     p_sub->pf_close = sub_close;
95
96     /* Initialize the variables */
97     var_Create( p_this, "sub-file", VLC_VAR_FILE | VLC_VAR_DOINHERIT );
98     var_Create( p_this, "sub-fps", VLC_VAR_FLOAT | VLC_VAR_DOINHERIT );
99     var_Create( p_this, "sub-delay", VLC_VAR_INTEGER | VLC_VAR_DOINHERIT );
100     var_Create( p_this, "sub-type", VLC_VAR_STRING | VLC_VAR_DOINHERIT );
101
102     return VLC_SUCCESS;
103 }
104 #define MAX_TRY     256
105 #define MAX_LINE    2048
106
107 #define FREE( p ) if( p ) { free( p); (p) = NULL; }
108
109 typedef struct
110 {
111     int     i_line_count;
112     int     i_line;
113     char    **line;
114 } text_t;
115
116 static int  text_load( text_t *txt, char *psz_name )
117 {
118     FILE *f;
119     int   i_line_max;
120
121     /* init txt */
122     i_line_max          = 100;
123     txt->i_line_count   = 0;
124     txt->i_line         = 0;
125     txt->line           = calloc( i_line_max, sizeof( char * ) );
126
127     /* open file */
128     if( !( f = fopen( psz_name, "rb" ) ) )
129     {
130         return VLC_EGENERIC;
131     }
132
133     /* load the complete file */
134     for( ;; )
135     {
136         char buffer[8096];
137         char *p;
138
139         if( fgets( buffer, 8096, f ) <= 0)
140         {
141             break;
142         }
143         while( ( p = strchr( buffer, '\r' ) ) )
144         {
145             *p = '\0';
146         }
147         while( ( p = strchr( buffer, '\n' ) ) )
148         {
149             *p = '\0';
150         }
151
152         txt->line[txt->i_line_count++] = strdup( buffer );
153
154         if( txt->i_line_count >= i_line_max )
155         {
156             i_line_max += 100;
157             txt->line = realloc( txt->line, i_line_max * sizeof( char*) );
158         }
159     }
160
161     fclose( f );
162
163     if( txt->i_line_count <= 0 )
164     {
165         FREE( txt->line );
166         return( VLC_EGENERIC );
167     }
168
169     return( VLC_SUCCESS );
170 }
171 static void text_unload( text_t *txt )
172 {
173     int i;
174
175     for( i = 0; i < txt->i_line_count; i++ )
176     {
177         FREE( txt->line[i] );
178     }
179     FREE( txt->line );
180     txt->i_line       = 0;
181     txt->i_line_count = 0;
182 }
183
184 static char *text_get_line( text_t *txt )
185 {
186     if( txt->i_line >= txt->i_line_count )
187     {
188         return( NULL );
189     }
190
191     return( txt->line[txt->i_line++] );
192 }
193 static void text_previous_line( text_t *txt )
194 {
195     if( txt->i_line > 0 )
196     {
197         txt->i_line--;
198     }
199 }
200 static void text_rewind( text_t *txt )
201 {
202     txt->i_line = 0;
203 }
204
205 static int  sub_MicroDvdRead( text_t *txt, subtitle_t *p_subtitle, mtime_t i_microsecperframe );
206 static int  sub_SubRipRead  ( text_t *txt, subtitle_t *p_subtitle, mtime_t i_microsecperframe );
207 static int  sub_SSA1Read    ( text_t *txt, subtitle_t *p_subtitle, mtime_t i_microsecperframe );
208 static int  sub_SSA2_4Read  ( text_t *txt, subtitle_t *p_subtitle, mtime_t i_microsecperframe );
209 static int  sub_Vplayer     ( text_t *txt, subtitle_t *p_subtitle, mtime_t i_microsecperframe );
210 static int  sub_Sami        ( text_t *txt, subtitle_t *p_subtitle, mtime_t i_microsecperframe );
211
212 static struct
213 {
214     char *psz_type_name;
215     int  i_type;
216     char *psz_name;
217     int  (*pf_read_subtitle)    ( text_t *, subtitle_t*, mtime_t );
218 } sub_read_subtitle_function [] =
219 {
220     { "microdvd",   SUB_TYPE_MICRODVD,  "MicroDVD", sub_MicroDvdRead },
221     { "subrip",     SUB_TYPE_SUBRIP,    "SubRIP",   sub_SubRipRead },
222     { "ssa1",       SUB_TYPE_SSA1,      "SSA-1",    sub_SSA1Read },
223     { "ssa2-4",     SUB_TYPE_SSA2_4,    "SSA-2/3/4",sub_SSA2_4Read },
224     { "vplayer",    SUB_TYPE_VPLAYER,   "VPlayer",  sub_Vplayer },
225     { "sami",       SUB_TYPE_SAMI,      "SAMI",     sub_Sami },
226     { NULL,         SUB_TYPE_UNKNOWN,   "Unknow",   NULL }
227 };
228
229 /*****************************************************************************
230  * sub_open: Open a subtitle file and add subtitle ES
231  *****************************************************************************/
232 static int  sub_open ( subtitle_demux_t *p_sub,
233                        input_thread_t  *p_input,
234                        char     *psz_name,
235                        mtime_t i_microsecperframe )
236 {
237     text_t  txt;
238     vlc_value_t val;
239
240     int     i;
241     int     i_sub_type;
242     int     i_max;
243     int (*pf_read_subtitle)( text_t *, subtitle_t *, mtime_t ) = NULL;
244
245     p_sub->i_sub_type = SUB_TYPE_UNKNOWN;
246     p_sub->p_es = NULL;
247     p_sub->i_subtitles = 0;
248     p_sub->subtitle = NULL;
249     p_sub->p_input = p_input;
250
251     if( !psz_name || !*psz_name)
252     {
253         var_Get( p_sub, "sub-file", &val );
254         if( !val.psz_string || !*val.psz_string )
255         {
256             if( val.psz_string ) free( val.psz_string );
257             return VLC_EGENERIC;
258         }
259         psz_name = val.psz_string;
260     }
261     else
262     {
263         psz_name = strdup( psz_name );
264     }
265
266     /* *** load the file *** */
267     if( text_load( &txt, psz_name ) )
268     {
269         msg_Err( p_sub, "cannot open `%s' subtitle file", psz_name );
270         free( psz_name );
271         return VLC_EGENERIC;
272     }
273     msg_Dbg( p_sub, "opened `%s'", psz_name );
274     free( psz_name );
275
276     var_Get( p_sub, "sub-fps", &val );
277     if( val.i_int >= 1.0 )
278     {
279         var_Get( p_sub, "sub-fps", &val );
280         i_microsecperframe = (mtime_t)( (float)1000000 / val.f_float );
281     }
282     else if( i_microsecperframe <= 0 )
283     {
284         i_microsecperframe = 40000; /* default: 25fps */
285     }
286
287     var_Get( p_sub, "sub-type", &val);
288     if( val.psz_string && *val.psz_string )
289     {
290         int i;
291
292         for( i = 0; ; i++ )
293         {
294             if( sub_read_subtitle_function[i].psz_type_name == NULL )
295             {
296                 i_sub_type = SUB_TYPE_UNKNOWN;
297                 break;
298             }
299             if( !strcmp( sub_read_subtitle_function[i].psz_type_name,
300                          val.psz_string ) )
301             {
302                 i_sub_type = sub_read_subtitle_function[i].i_type;
303                 break;
304             }
305         }
306     }
307     else
308     {
309         i_sub_type = SUB_TYPE_UNKNOWN;
310     }
311     FREE( val.psz_string );
312
313     /* *** Now try to autodetect subtitle format *** */
314     if( i_sub_type == SUB_TYPE_UNKNOWN )
315     {
316         int     i_try;
317         char    *s;
318
319         msg_Dbg( p_input, "trying to autodetect file format" );
320         for( i_try = 0; i_try < MAX_TRY; i_try++ )
321         {
322             int i_dummy;
323
324             if( ( s = text_get_line( &txt ) ) == NULL )
325             {
326                 break;
327             }
328
329             if( strstr( s, "<SAMI>" ) )
330             {
331                 i_sub_type = SUB_TYPE_SAMI;
332                 break;
333             }
334             else if( sscanf( s, "{%d}{%d}", &i_dummy, &i_dummy ) == 2 ||
335                      sscanf( s, "{%d}{}", &i_dummy ) == 1)
336             {
337                 i_sub_type = SUB_TYPE_MICRODVD;
338                 break;
339             }
340             else if( sscanf( s,
341                              "%d:%d:%d,%d --> %d:%d:%d,%d",
342                              &i_dummy,&i_dummy,&i_dummy,&i_dummy,
343                              &i_dummy,&i_dummy,&i_dummy,&i_dummy ) == 8 )
344             {
345                 i_sub_type = SUB_TYPE_SUBRIP;
346                 break;
347             }
348             else if( sscanf( s,
349                              "!: This is a Sub Station Alpha v%d.x script.",
350                              &i_dummy ) == 1)
351             {
352                 if( i_dummy <= 1 )
353                 {
354                     i_sub_type = SUB_TYPE_SSA1;
355                 }
356                 else
357                 {
358                     i_sub_type = SUB_TYPE_SSA2_4; // I hop this will work
359                 }
360                 break;
361             }
362             else if( strstr( s, "This is a Sub Station Alpha v4 script" ) )
363             {
364                 i_sub_type = SUB_TYPE_SSA2_4; // I hop this will work
365             }
366             else if( !strncmp( s, "Dialogue: Marked", 16  ) )
367             {
368                 i_sub_type = SUB_TYPE_SSA2_4; // could be wrong
369                 break;
370             }
371             else if( sscanf( s, "%d:%d:%d:", &i_dummy, &i_dummy, &i_dummy ) == 3 ||
372                      sscanf( s, "%d:%d:%d ", &i_dummy, &i_dummy, &i_dummy ) == 3 )
373             {
374                 i_sub_type = SUB_TYPE_VPLAYER;
375                 break;
376             }
377         }
378
379         text_rewind( &txt );
380     }
381
382     /* *** Load this file in memory *** */
383     for( i = 0; ; i++ )
384     {
385         if( sub_read_subtitle_function[i].i_type == SUB_TYPE_UNKNOWN )
386         {
387             msg_Dbg( p_input, "unknown subtitle file" );
388             text_unload( &txt );
389             return VLC_EGENERIC;
390         }
391
392         if( sub_read_subtitle_function[i].i_type == i_sub_type )
393         {
394             msg_Dbg( p_input, "detected %s format",
395                     sub_read_subtitle_function[i].psz_name );
396             pf_read_subtitle = sub_read_subtitle_function[i].pf_read_subtitle;
397             break;
398         }
399     }
400
401     for( i_max = 0;; )
402     {
403         if( p_sub->i_subtitles >= i_max )
404         {
405             i_max += 128;
406             if( p_sub->subtitle )
407             {
408                 p_sub->subtitle = realloc( p_sub->subtitle,
409                                            sizeof( subtitle_t ) * i_max );
410             }
411             else
412             {
413                 p_sub->subtitle = malloc( sizeof( subtitle_t ) * i_max );
414             }
415         }
416         if( pf_read_subtitle( &txt,
417                               p_sub->subtitle + p_sub->i_subtitles,
418                               i_microsecperframe ) < 0 )
419         {
420             break;
421         }
422         p_sub->i_subtitles++;
423     }
424     msg_Dbg( p_sub, "loaded %d subtitles", p_sub->i_subtitles );
425
426     /* *** Close the file *** */
427     text_unload( &txt );
428
429     /* *** fix subtitle (order and time) *** */
430     p_sub->i_subtitle = 0;  // will be modified by sub_fix
431     sub_fix( p_sub );
432
433     /* *** add subtitle ES *** */
434     vlc_mutex_lock( &p_input->stream.stream_lock );
435     p_sub->p_es = input_AddES( p_input, p_input->stream.p_selected_program,
436                                0xff,    // FIXME
437                                SPU_ES, NULL, 0 );
438     vlc_mutex_unlock( &p_input->stream.stream_lock );
439
440     p_sub->p_es->i_stream_id = 0xff;    // FIXME
441     p_sub->p_es->i_fourcc    = VLC_FOURCC( 's','u','b','t' );
442
443     p_sub->i_previously_selected = 0;
444     return VLC_SUCCESS;
445 }
446
447 /*****************************************************************************
448  * sub_demux: Send subtitle to decoder until i_maxdate
449  *****************************************************************************/
450 static int  sub_demux( subtitle_demux_t *p_sub, mtime_t i_maxdate )
451 {
452     if( p_sub->p_es->p_decoder_fifo && !p_sub->i_previously_selected )
453     {
454         p_sub->i_previously_selected = 1;
455         p_sub->pf_seek( p_sub, i_maxdate );
456         return VLC_SUCCESS;
457     }
458     else if( !p_sub->p_es->p_decoder_fifo && p_sub->i_previously_selected )
459     {
460         p_sub->i_previously_selected = 0;
461         return VLC_SUCCESS;
462     }
463
464     while( p_sub->i_subtitle < p_sub->i_subtitles &&
465            p_sub->subtitle[p_sub->i_subtitle].i_start < i_maxdate )
466     {
467         pes_packet_t    *p_pes;
468         data_packet_t   *p_data;
469
470         int i_len;
471
472         i_len = strlen( p_sub->subtitle[p_sub->i_subtitle].psz_text ) + 1;
473
474         if( i_len <= 1 )
475         {
476             /* empty subtitle */
477             p_sub->i_subtitle++;
478             continue;
479         }
480         if( !( p_pes = input_NewPES( p_sub->p_input->p_method_data ) ) )
481         {
482             p_sub->i_subtitle++;
483             continue;
484         }
485
486         if( !( p_data = input_NewPacket( p_sub->p_input->p_method_data,
487                                          i_len ) ) )
488         {
489             input_DeletePES( p_sub->p_input->p_method_data, p_pes );
490             p_sub->i_subtitle++;
491             continue;
492         }
493         p_data->p_payload_end = p_data->p_payload_start + i_len;
494
495         p_pes->i_pts =
496             input_ClockGetTS( p_sub->p_input,
497                               p_sub->p_input->stream.p_selected_program,
498                               p_sub->subtitle[p_sub->i_subtitle].i_start*9/100);
499         if( p_sub->subtitle[p_sub->i_subtitle].i_stop > 0 )
500         {
501             /* FIXME kludge ...
502              * i_dts means end of display...
503              */
504             p_pes->i_dts =
505                 input_ClockGetTS( p_sub->p_input,
506                               p_sub->p_input->stream.p_selected_program,
507                               p_sub->subtitle[p_sub->i_subtitle].i_stop *9/100);
508         }
509         else
510         {
511             p_pes->i_dts = 0;
512         }
513
514         p_pes->i_nb_data = 1;
515         p_pes->p_first =
516             p_pes->p_last = p_data;
517         p_pes->i_pes_size = i_len;
518
519         memcpy( p_data->p_payload_start,
520                 p_sub->subtitle[p_sub->i_subtitle].psz_text,
521                 i_len );
522         if( p_sub->p_es->p_decoder_fifo && p_pes->i_pts > 0 )
523         {
524
525             input_DecodePES( p_sub->p_es->p_decoder_fifo, p_pes );
526         }
527         else
528         {
529             input_DeletePES( p_sub->p_input->p_method_data, p_pes );
530         }
531
532         p_sub->i_subtitle++;
533     }
534     return( 0 );
535 }
536
537 /*****************************************************************************
538  * sub_seek: Seek to i_date
539  *****************************************************************************/
540 static int  sub_seek ( subtitle_demux_t *p_sub, mtime_t i_date )
541 {
542     /* should be fast enough... */
543     p_sub->i_subtitle = 0;
544     while( p_sub->i_subtitle < p_sub->i_subtitles &&
545            p_sub->subtitle[p_sub->i_subtitle].i_start < i_date )
546     {
547         p_sub->i_subtitle++;
548     }
549
550     return( 0 );
551 }
552
553 /*****************************************************************************
554  * sub_close: Close subtitle demux
555  *****************************************************************************/
556 static void sub_close( subtitle_demux_t *p_sub )
557 {
558     if( p_sub->subtitle )
559     {
560         int i;
561         for( i = 0; i < p_sub->i_subtitles; i++ )
562         {
563             if( p_sub->subtitle[i].psz_text )
564             {
565                 free( p_sub->subtitle[i].psz_text );
566             }
567         }
568         free( p_sub->subtitle );
569     }
570 }
571 /*****************************************************************************
572  *
573  * sub_fix: fix time stamp and order of subtitle
574  *****************************************************************************/
575 static void  sub_fix( subtitle_demux_t *p_sub )
576 {
577     int     i;
578     mtime_t i_delay;
579     int     i_index;
580     int     i_done;
581     vlc_value_t val;
582
583     /* *** fix order (to be sure...) *** */
584     /* We suppose that there are near in order and this durty bubble sort
585      * wont take too much time
586      */
587     do
588     {
589         i_done = 1;
590         for( i_index = 1; i_index < p_sub->i_subtitles; i_index++ )
591         {
592             if( p_sub->subtitle[i_index].i_start <
593                     p_sub->subtitle[i_index - 1].i_start )
594             {
595                 subtitle_t sub_xch;
596                 memcpy( &sub_xch,
597                         p_sub->subtitle + i_index - 1,
598                         sizeof( subtitle_t ) );
599                 memcpy( p_sub->subtitle + i_index - 1,
600                         p_sub->subtitle + i_index,
601                         sizeof( subtitle_t ) );
602                 memcpy( p_sub->subtitle + i_index,
603                         &sub_xch,
604                         sizeof( subtitle_t ) );
605                 i_done = 0;
606             }
607         }
608     } while( !i_done );
609
610     /* *** and at the end add delay *** */
611     var_Get( p_sub, "sub-delay", &val );
612     i_delay = (mtime_t) val.i_int * 100000;
613     if( i_delay != 0 )
614     {
615         for( i = 0; i < p_sub->i_subtitles; i++ )
616         {
617             p_sub->subtitle[i].i_start += i_delay;
618             p_sub->subtitle[i].i_stop += i_delay;
619             if( p_sub->subtitle[i].i_start < 0 )
620             {
621                 p_sub->i_subtitle = i + 1;
622             }
623         }
624     }
625 }
626
627
628
629 /*****************************************************************************
630  * Specific Subtitle function
631  *****************************************************************************/
632 static int  sub_MicroDvdRead( text_t *txt, subtitle_t *p_subtitle, mtime_t i_microsecperframe)
633 {
634     /*
635      * each line:
636      *  {n1}{n2}Line1|Line2|Line3....
637      * where n1 and n2 are the video frame number...
638      *
639      */
640     char *s;
641
642     char buffer_text[MAX_LINE + 1];
643     uint32_t    i_start;
644     uint32_t    i_stop;
645     unsigned int i;
646
647     for( ;; )
648     {
649         if( ( s = text_get_line( txt ) ) == NULL )
650         {
651             return( VLC_EGENERIC );
652         }
653         i_start = 0;
654         i_stop  = 0;
655
656         memset( buffer_text, '\0', MAX_LINE );
657         if( sscanf( s, "{%d}{}%[^\r\n]", &i_start, buffer_text ) == 2 ||
658             sscanf( s, "{%d}{%d}%[^\r\n]", &i_start, &i_stop, buffer_text ) == 3)
659         {
660             break;
661         }
662     }
663     /* replace | by \n */
664     for( i = 0; i < strlen( buffer_text ); i++ )
665     {
666         if( buffer_text[i] == '|' )
667         {
668             buffer_text[i] = '\n';
669         }
670     }
671     p_subtitle->i_start = (mtime_t)i_start * (mtime_t)i_microsecperframe;
672     p_subtitle->i_stop  = (mtime_t)i_stop  * (mtime_t)i_microsecperframe;
673     p_subtitle->psz_text = strndup( buffer_text, MAX_LINE );
674     return( 0 );
675 }
676
677 static int  sub_SubRipRead( text_t *txt, subtitle_t *p_subtitle, mtime_t i_microsecperframe )
678 {
679     /*
680      * n
681      * h1:m1:s1,d1 --> h2:m2:s2,d2
682      * Line1
683      * Line2
684      * ...
685      * [empty line]
686      *
687      */
688     char *s;
689     char buffer_text[ 10 * MAX_LINE];
690     int  i_buffer_text;
691     mtime_t     i_start;
692     mtime_t     i_stop;
693
694     for( ;; )
695     {
696         int h1, m1, s1, d1, h2, m2, s2, d2;
697         if( ( s = text_get_line( txt ) ) == NULL )
698         {
699             return( VLC_EGENERIC );
700         }
701         if( sscanf( s,
702                     "%d:%d:%d,%d --> %d:%d:%d,%d",
703                     &h1, &m1, &s1, &d1,
704                     &h2, &m2, &s2, &d2 ) == 8 )
705         {
706             i_start = ( (mtime_t)h1 * 3600*1000 +
707                         (mtime_t)m1 * 60*1000 +
708                         (mtime_t)s1 * 1000 +
709                         (mtime_t)d1 ) * 1000;
710
711             i_stop  = ( (mtime_t)h2 * 3600*1000 +
712                         (mtime_t)m2 * 60*1000 +
713                         (mtime_t)s2 * 1000 +
714                         (mtime_t)d2 ) * 1000;
715
716             /* Now read text until an empty line */
717             for( i_buffer_text = 0;; )
718             {
719                 int i_len;
720                 if( ( s = text_get_line( txt ) ) == NULL )
721                 {
722                     return( VLC_EGENERIC );
723                 }
724
725                 i_len = strlen( s );
726                 if( i_len <= 1 )
727                 {
728                     // empty line -> end of this subtitle
729                     buffer_text[__MAX( i_buffer_text - 1, 0 )] = '\0';
730                     p_subtitle->i_start = i_start;
731                     p_subtitle->i_stop = i_stop;
732                     p_subtitle->psz_text = strdup( buffer_text );
733                     return( 0 );
734                 }
735                 else
736                 {
737                     if( i_buffer_text + i_len + 1 < 10 * MAX_LINE )
738                     {
739                         memcpy( buffer_text + i_buffer_text,
740                                 s,
741                                 i_len );
742                         i_buffer_text += i_len;
743
744                         buffer_text[i_buffer_text] = '\n';
745                         i_buffer_text++;
746                     }
747                 }
748             }
749         }
750     }
751 }
752
753
754 static int  sub_SSARead( text_t *txt, subtitle_t *p_subtitle, mtime_t i_microsecperframe, int i_comma_count )
755 {
756     char buffer_text[ 10 * MAX_LINE];
757     char *s;
758     char *p_buffer_text;
759     mtime_t     i_start;
760     mtime_t     i_stop;
761     int         i_comma;
762     int         i_text;
763
764     for( ;; )
765     {
766         int h1, m1, s1, c1, h2, m2, s2, c2;
767         int i_dummy;
768
769         if( ( s = text_get_line( txt ) ) == NULL )
770         {
771             return( VLC_EGENERIC );
772         }
773         if( sscanf( s,
774                     "Dialogue: Marked=%d,%d:%d:%d.%d,%d:%d:%d.%d,%[^\r\n]",
775                     &i_dummy,
776                     &h1, &m1, &s1, &c1,
777                     &h2, &m2, &s2, &c2,
778                     buffer_text ) == 10 )
779         {
780             i_start = ( (mtime_t)h1 * 3600*1000 +
781                         (mtime_t)m1 * 60*1000 +
782                         (mtime_t)s1 * 1000 +
783                         (mtime_t)c1 * 10 ) * 1000;
784
785             i_stop  = ( (mtime_t)h2 * 3600*1000 +
786                         (mtime_t)m2 * 60*1000 +
787                         (mtime_t)s2 * 1000 +
788                         (mtime_t)c2 * 10 ) * 1000;
789
790             p_buffer_text = buffer_text;
791             i_comma = 3;
792             while( i_comma < i_comma_count &&
793                    *p_buffer_text != '\0' )
794             {
795                 if( *p_buffer_text == ',' )
796                 {
797                     i_comma++;
798                 }
799                 p_buffer_text++;
800             }
801             p_subtitle->psz_text = malloc( strlen( p_buffer_text ) + 1);
802             i_text = 0;
803             while( *p_buffer_text )
804             {
805                 if( *p_buffer_text == '\\' && ( *p_buffer_text =='n' || *p_buffer_text =='N' ) )
806                 {
807                     p_subtitle->psz_text[i_text] = '\n';
808                     i_text++;
809                     p_buffer_text += 2;
810                 }
811                 else if( *p_buffer_text == '{' && *p_buffer_text == '\\')
812                 {
813                     while( *p_buffer_text && *p_buffer_text != '}' )
814                     {
815                         p_buffer_text++;
816                     }
817                 }
818                 else
819                 {
820                     p_subtitle->psz_text[i_text] = *p_buffer_text;
821                     i_text++;
822                     p_buffer_text++;
823                 }
824             }
825             p_subtitle->psz_text[i_text] = '\0';
826             p_subtitle->i_start = i_start;
827             p_subtitle->i_stop = i_stop;
828             return( 0 );
829         }
830     }
831 }
832
833 static int  sub_SSA1Read( text_t *txt, subtitle_t *p_subtitle, mtime_t i_microsecperframe )
834 {
835     return( sub_SSARead( txt, p_subtitle, i_microsecperframe, 8 ) );
836 }
837 static int  sub_SSA2_4Read( text_t *txt, subtitle_t *p_subtitle, mtime_t i_microsecperframe )
838 {
839     return( sub_SSARead( txt, p_subtitle, i_microsecperframe, 9 ) );
840 }
841
842 static int  sub_Vplayer( text_t *txt, subtitle_t *p_subtitle, mtime_t i_microsecperframe)
843 {
844     /*
845      * each line:
846      *  h:m:s:Line1|Line2|Line3....
847      *  or
848      *  h:m:s Line1|Line2|Line3....
849      * where n1 and n2 are the video frame number...
850      *
851      */
852     char *p;
853     char buffer_text[MAX_LINE + 1];
854     mtime_t    i_start;
855     unsigned int i;
856
857     for( ;; )
858     {
859         int h, m, s;
860         char c;
861
862         if( ( p = text_get_line( txt ) ) == NULL )
863         {
864             return( VLC_EGENERIC );
865         }
866
867         i_start = 0;
868
869         memset( buffer_text, '\0', MAX_LINE );
870         if( sscanf( p, "%d:%d:%d%[ :]%[^\r\n]", &h, &m, &s, &c, buffer_text ) == 5 )
871         {
872             i_start = ( (mtime_t)h * 3600*1000 +
873                         (mtime_t)m * 60*1000 +
874                         (mtime_t)s * 1000 ) * 1000;
875             break;
876         }
877     }
878
879     /* replace | by \n */
880     for( i = 0; i < strlen( buffer_text ); i++ )
881     {
882         if( buffer_text[i] == '|' )
883         {
884             buffer_text[i] = '\n';
885         }
886     }
887     p_subtitle->i_start = i_start;
888
889     p_subtitle->i_stop  = 0;
890     p_subtitle->psz_text = strndup( buffer_text, MAX_LINE );
891     return( 0 );
892 }
893
894 static char *sub_SamiSearch( text_t *txt, char *psz_start, char *psz_str )
895 {
896     if( psz_start )
897     {
898         if( strstr( psz_start, psz_str ) )
899         {
900             char *s = strstr( psz_start, psz_str );
901
902             s += strlen( psz_str );
903
904             return( s );
905         }
906     }
907     for( ;; )
908     {
909         char *p;
910         if( ( p = text_get_line( txt ) ) == NULL )
911         {
912             return NULL;
913         }
914         if( strstr( p, psz_str ) )
915         {
916             char *s = strstr( p, psz_str );
917
918             s += strlen( psz_str );
919
920             return(  s);
921         }
922     }
923 }
924
925 static int  sub_Sami( text_t *txt, subtitle_t *p_subtitle, mtime_t i_microsecperframe )
926 {
927     char *p;
928     int i_start;
929
930     int  i_text;
931     char buffer_text[10*MAX_LINE + 1];
932 #define ADDC( c ) \
933     if( i_text < 10*MAX_LINE )      \
934     {                               \
935         buffer_text[i_text++] = c;  \
936         buffer_text[i_text] = '\0'; \
937     }
938
939     /* search "Start=" */
940     if( !( p = sub_SamiSearch( txt, NULL, "Start=" ) ) )
941     {
942         return VLC_EGENERIC;
943     }
944
945     /* get start value */
946     i_start = strtol( p, &p, 0 );
947
948     /* search <P */
949     if( !( p = sub_SamiSearch( txt, p, "<P" ) ) )
950     {
951         return VLC_EGENERIC;
952     }
953     /* search > */
954     if( !( p = sub_SamiSearch( txt, p, ">" ) ) )
955     {
956         return VLC_EGENERIC;
957     }
958
959     i_text = 0;
960     buffer_text[0] = '\0';
961     /* now get all txt until  a "Start=" line */
962     for( ;; )
963     {
964         if( *p )
965         {
966             if( *p == '<' )
967             {
968                 if( !strncmp( p, "<br", 3 ) || !strncmp( p, "<BR", 3 ) )
969                 {
970                     ADDC( '\n' );
971                 }
972                 else if( strstr( p, "Start=" ) )
973                 {
974                     text_previous_line( txt );
975                     break;
976                 }
977                 p = sub_SamiSearch( txt, p, ">" );
978             }
979             else if( !strncmp( p, "&nbsp;", 6 ) )
980             {
981                 ADDC( ' ' );
982                 p += 6;
983             }
984             else if( *p == '\t' )
985             {
986                 ADDC( ' ' );
987                 p++;
988             }
989             else
990             {
991                 ADDC( *p );
992                 p++;
993             }
994         }
995         else
996         {
997             p = text_get_line( txt );
998         }
999
1000         if( p == NULL )
1001         {
1002             break;
1003         }
1004     }
1005
1006     p_subtitle->i_start = i_start * 1000;
1007     p_subtitle->i_stop  = 0;
1008     p_subtitle->psz_text = strndup( buffer_text, 10*MAX_LINE );
1009
1010     return( VLC_SUCCESS );
1011 #undef ADDC
1012 }
1013