61b03f044bceaab291add1779c3bfd1389fff69a
[vlc.git] / modules / demux / util / sub.c
1 /*****************************************************************************
2  * sub.c
3  *****************************************************************************
4  * Copyright (C) 1999-2001 VideoLAN
5  * $Id: sub.c,v 1.4 2003/02/08 19:10:21 massiot 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
35 #include "video.h"
36
37 #include "sub.h"
38
39
40 static int  Open ( vlc_object_t *p_this );
41
42 static int  sub_open ( subtitle_demux_t *p_sub, 
43                        input_thread_t  *p_input,
44                        char  *psz_name,
45                        mtime_t i_microsecperframe );
46 static int  sub_demux( subtitle_demux_t *p_sub, mtime_t i_maxdate );
47 static int  sub_seek ( subtitle_demux_t *p_sub, mtime_t i_date );
48 static void sub_close( subtitle_demux_t *p_sub );
49
50 static int  sub_MicroDvdRead( FILE *p_file, subtitle_t *p_subtitle, mtime_t i_microsecperframe );
51 static int  sub_SubRipRead( FILE *p_file, subtitle_t *p_subtitle, mtime_t i_microsecperframe );
52 static int  sub_SSA1Read( FILE *p_file, subtitle_t *p_subtitle, mtime_t i_microsecperframe );
53 static int  sub_SSA2_4Read( FILE *p_file, subtitle_t *p_subtitle, mtime_t i_microsecperframe );
54
55 static void sub_fix( subtitle_demux_t *p_sub );
56
57 static char *ppsz_sub_type[] = { "microdvd", "subrip", "ssa1", "ssa2-4", NULL };
58 /*****************************************************************************
59  * Module descriptor
60  *****************************************************************************/
61
62 #define SUB_FPS_LONGTEXT \
63     "Override frames per second. " \
64     "It will work only with MicroDVD"
65 #define SUB_TYPE_LONGTEXT \
66     "One from \"microdvd\", \"subrip\", \"ssa1\", \"ssa2-4\" " \
67     "(nothing for autodetection, it should always work)"
68
69 vlc_module_begin();
70     set_description( _("text subtitle demux") );
71     set_capability( "subtitle demux", 12 );
72     add_category_hint( "subtitle", NULL );
73         add_string( "sub-file", NULL, NULL,
74                     "subtitle file name", "subtitle file name" );
75         add_float( "sub-fps", 0.0, NULL, 
76                    "override frames per second",
77                    SUB_FPS_LONGTEXT );
78         add_integer( "sub-delay", 0, NULL,
79                      "delay subtitles (in 1/10s)", 
80                      "delay subtitles (in 1/10s)" );
81         add_string_from_list( "sub-type", NULL, ppsz_sub_type, NULL,
82                               "subtitle type", 
83                               SUB_TYPE_LONGTEXT );
84     set_callbacks( Open, NULL );
85 vlc_module_end();
86
87 /*****************************************************************************
88  * Module initializer
89  *****************************************************************************/
90 static int Open ( vlc_object_t *p_this )
91 {
92     subtitle_demux_t *p_sub = (subtitle_demux_t*)p_this;
93
94     p_sub->pf_open  = sub_open;
95     p_sub->pf_demux = sub_demux;
96     p_sub->pf_seek  = sub_seek;
97     p_sub->pf_close = sub_close;
98     
99     return VLC_SUCCESS;
100 }
101 #define MAX_TRY     256
102 #define MAX_LINE    2048
103 /*****************************************************************************
104  * sub_open: Open a subtitle file and add subtitle ES
105  *****************************************************************************/
106 static int  sub_open ( subtitle_demux_t *p_sub, 
107                        input_thread_t  *p_input,
108                        char     *psz_name,
109                        mtime_t i_microsecperframe )
110 {
111     FILE *p_file;
112     char    *psz_file_type;
113     char    buffer[MAX_LINE + 1];
114     int     i_try;
115     int     i_sub_type;
116     int     i_max;
117     int (*pf_read_subtitle)( FILE *p_file, subtitle_t *p_subtitle, mtime_t i_microsecperframe ) = NULL;
118    
119         
120     p_sub->i_sub_type = SUB_TYPE_UNKNOWN;
121     p_sub->p_es = NULL;
122     p_sub->i_subtitles = 0;
123     p_sub->subtitle = NULL;
124     p_sub->p_input = p_input;
125
126     if( !psz_name || !*psz_name)
127     {
128         psz_name = config_GetPsz( p_sub, "sub-file" );
129         if( !psz_name || !*psz_name )
130         {
131             return( -1 );
132         }
133     }
134
135     if(  config_GetFloat( p_sub, "sub-fps" ) >= 1.0 )
136     {
137         i_microsecperframe = (mtime_t)( (float)1000000 / 
138                                         config_GetFloat( p_sub, "sub-fps" ) );
139     }
140     else if( i_microsecperframe <= 0 )
141     {
142         i_microsecperframe = 40000; /* default: 25fps */
143     }
144
145     /* *** Open the file *** */
146     if( !( p_file = fopen( psz_name, "rb" ) ) )
147     {
148         msg_Err( p_sub, "cannot open `%s' subtitle file", psz_name );
149
150     }
151     else
152     {
153         msg_Dbg( p_sub, "opened `%s'", psz_name );
154     }
155
156     psz_file_type = config_GetPsz( p_sub, "sub-type" );
157     if( psz_file_type && *psz_file_type)
158     {
159         if( !strcmp( psz_file_type, "microdvd" ) )
160         {
161             i_sub_type = SUB_TYPE_MICRODVD;
162         }
163         else if( !strcmp( psz_file_type, "subrip" ) )
164         {
165             i_sub_type = SUB_TYPE_SUBRIP;
166         }
167         else if( !strcmp( psz_file_type, "ssa1" ) )
168         {
169             i_sub_type = SUB_TYPE_SSA1;
170         }
171         else if( !strcmp( psz_file_type, "ssa2-4" ) )
172         {
173             i_sub_type = SUB_TYPE_SSA2_4;
174         }
175         else
176         {
177             i_sub_type = SUB_TYPE_UNKNOWN;
178         }
179     }
180     else
181     {
182         i_sub_type = SUB_TYPE_UNKNOWN;
183     }
184    
185     /* *** Now try to autodetect subtitle format *** */
186     if( i_sub_type == SUB_TYPE_UNKNOWN )
187     {
188         msg_Dbg( p_input, "trying to autodetect file format" );
189         for( i_try = 0; i_try < MAX_TRY; i_try++ )
190         {
191             int i_dummy;
192             if( fgets( buffer, MAX_LINE, p_file ) <= 0 )
193             {
194                 break;
195             }
196
197             if( sscanf( buffer, "{%d}{%d}", &i_dummy, &i_dummy ) == 2 ||
198                 sscanf( buffer, "{%d}{}", &i_dummy ) == 1)
199             {
200                 i_sub_type = SUB_TYPE_MICRODVD;
201                 break;
202             }
203             else if( sscanf( buffer, 
204                              "%d:%d:%d,%d --> %d:%d:%d,%d",
205                              &i_dummy,&i_dummy,&i_dummy,&i_dummy, 
206                              &i_dummy,&i_dummy,&i_dummy,&i_dummy ) == 8 )
207             {
208                 i_sub_type = SUB_TYPE_SUBRIP;
209                 break;
210             }
211             else if( sscanf( buffer, 
212                              "!: This is a Sub Station Alpha v%d.x script.",
213                              &i_dummy ) == 1)
214             {
215                 if( i_dummy <= 1 )
216                 {
217                     i_sub_type = SUB_TYPE_SSA1;
218                 }
219                 else
220                 {
221                     i_sub_type = SUB_TYPE_SSA2_4; // I hop this will work
222                 }
223             }
224             else if( !strcmp( buffer,
225                               "Dialogue: Marked" ) )
226             {
227                 i_sub_type = SUB_TYPE_SSA2_4; // could be wrong
228             }
229                               
230             
231         }
232     }
233
234     /* *** Load this file in memory *** */
235     switch( i_sub_type )
236     {
237         case SUB_TYPE_MICRODVD:
238             msg_Dbg( p_input, "detected MicroDVD format" );
239             pf_read_subtitle = sub_MicroDvdRead;
240             break;
241         case SUB_TYPE_SUBRIP:
242             msg_Dbg( p_input, "detected SubRIP format" );
243             pf_read_subtitle = sub_SubRipRead;
244             break;
245         case SUB_TYPE_SSA1:
246             msg_Dbg( p_input, "detected SSAv1 Script format" );
247             pf_read_subtitle = sub_SSA1Read;
248             break;
249         case SUB_TYPE_SSA2_4:
250             msg_Dbg( p_input, "detected SSAv2-4 Script format" );
251             pf_read_subtitle = sub_SSA2_4Read;
252             break;
253         default:
254             msg_Err( p_sub, "unknown subtitile file" );
255             fclose( p_file );
256             return( -1 );
257     }
258     
259     if( fseek( p_file, 0L, SEEK_SET ) < 0 )
260     {
261         msg_Err( p_input, "cannot read file from begining" );
262         fclose( p_file );
263         return( -1 );
264     }
265     for( i_max = 0;; )
266     {   
267         if( p_sub->i_subtitles <= i_max )
268         {
269             i_max += 128;
270             if( p_sub->subtitle )
271             {
272                 p_sub->subtitle = realloc( p_sub->subtitle, 
273                                            sizeof( subtitle_t ) * i_max );
274             }
275             else
276             {
277                 p_sub->subtitle = malloc( sizeof( subtitle_t ) * i_max );
278             }
279         }
280         if( pf_read_subtitle( p_file, 
281                               p_sub->subtitle + p_sub->i_subtitles, 
282                               i_microsecperframe ) < 0 )
283         {
284             break;
285         }
286         p_sub->i_subtitles++;
287     }
288     msg_Dbg( p_sub, "loaded %d subtitles", p_sub->i_subtitles );
289
290     
291     /* *** Close the file *** */
292     fclose( p_file );
293
294     /* *** fix subtitle (order and time) *** */
295     p_sub->i_subtitle = 0;  // will be modified by sub_fix
296     sub_fix( p_sub );
297     
298     /* *** add subtitle ES *** */
299     vlc_mutex_lock( &p_input->stream.stream_lock );
300     p_sub->p_es = input_AddES( p_input,
301                                p_input->stream.p_selected_program,
302                                0xff,    // FIXME
303                                0 );
304     vlc_mutex_unlock( &p_input->stream.stream_lock );
305
306     p_sub->p_es->i_stream_id = 0xff;    // FIXME
307     p_sub->p_es->i_fourcc    = VLC_FOURCC( 's','u','b','t' );
308     p_sub->p_es->i_cat       = SPU_ES;
309
310     p_sub->i_previously_selected = 0;
311     return( 0 );
312 }
313
314 /*****************************************************************************
315  * sub_demux: Send subtitle to decoder until i_maxdate
316  *****************************************************************************/
317 static int  sub_demux( subtitle_demux_t *p_sub, mtime_t i_maxdate )
318 {
319
320     if( p_sub->p_es->p_decoder_fifo && !p_sub->i_previously_selected )
321     {
322         p_sub->i_previously_selected = 1;
323         p_sub->pf_seek( p_sub, i_maxdate );
324         return( 0 );
325     }
326     else if( !p_sub->p_es->p_decoder_fifo && p_sub->i_previously_selected )
327     {
328         p_sub->i_previously_selected = 0;
329         return( 0 );
330     }
331
332     while( p_sub->i_subtitle < p_sub->i_subtitles &&
333            p_sub->subtitle[p_sub->i_subtitle].i_start < i_maxdate )
334     {
335         pes_packet_t    *p_pes;
336         data_packet_t   *p_data;
337         
338         int i_len;
339         
340         i_len = strlen( p_sub->subtitle[p_sub->i_subtitle].psz_text ) + 1;
341         
342         if( i_len <= 1 )
343         {
344             /* empty subtitle */
345             p_sub->i_subtitle++;
346             continue;
347         }
348         if( !( p_pes = input_NewPES( p_sub->p_input->p_method_data ) ) )
349         {
350             p_sub->i_subtitle++;
351             continue;
352         }
353         
354         if( !( p_data = input_NewPacket( p_sub->p_input->p_method_data, 
355                                          i_len ) ) )
356         {
357             input_DeletePES( p_sub->p_input->p_method_data, p_pes );
358             p_sub->i_subtitle++;
359             continue;
360         }
361         
362         p_pes->i_pts = 
363             input_ClockGetTS( p_sub->p_input, 
364                               p_sub->p_input->stream.p_selected_program,
365                               p_sub->subtitle[p_sub->i_subtitle].i_start*9/100);
366         if( p_sub->subtitle[p_sub->i_subtitle].i_stop > 0 )
367         {
368             /* FIXME kludge ... 
369              * i_dts means end of display...
370              */
371             p_pes->i_dts = 
372                 input_ClockGetTS( p_sub->p_input, 
373                               p_sub->p_input->stream.p_selected_program,
374                               p_sub->subtitle[p_sub->i_subtitle].i_stop *9/100);
375         }
376         else
377         {
378             p_pes->i_dts = 0;
379         }
380         p_pes->i_nb_data = 1;
381         p_pes->p_first = 
382             p_pes->p_last = p_data;
383         p_pes->i_pes_size = i_len;
384
385         memcpy( p_data->p_payload_start, 
386                 p_sub->subtitle[p_sub->i_subtitle].psz_text, 
387                 i_len );
388         if( p_sub->p_es->p_decoder_fifo )
389         {
390
391             input_DecodePES( p_sub->p_es->p_decoder_fifo, p_pes );
392         }
393         else
394         {
395             input_DeletePES( p_sub->p_input->p_method_data, p_pes );
396         }
397         
398         
399         p_sub->i_subtitle++;
400     }
401     return( 0 );
402 }
403
404 /*****************************************************************************
405  * sub_seek: Seek to i_date
406  *****************************************************************************/
407 static int  sub_seek ( subtitle_demux_t *p_sub, mtime_t i_date )
408 {
409     /* should be fast enough... */
410     p_sub->i_subtitle = 0;
411     while( p_sub->i_subtitle < p_sub->i_subtitles &&
412            p_sub->subtitle[p_sub->i_subtitle].i_start < i_date )
413     {
414         p_sub->i_subtitle++;
415     }
416
417     return( 0 );
418 }
419
420 /*****************************************************************************
421  * sub_close: Close subtitle demux
422  *****************************************************************************/
423 static void sub_close( subtitle_demux_t *p_sub )
424 {
425     if( p_sub->subtitle )
426     {
427         int i;
428         for( i = 0; i < p_sub->i_subtitles; i++ )
429         {
430             if( p_sub->subtitle[i].psz_text )
431             {
432                 free( p_sub->subtitle[i].psz_text );
433             }
434         }
435         free( p_sub->subtitle );
436     }
437 }
438 /*****************************************************************************
439  *
440  * sub_fix: fix time stamp and order of subtitle
441  *****************************************************************************/
442 static void  sub_fix( subtitle_demux_t *p_sub )
443 {
444     int     i;
445     mtime_t i_delay;
446     int     i_index;
447     int     i_done;
448
449     /* *** fix order (to be sure...) *** */
450     /* We suppose that there are near in order and this durty bubble sort
451      * wont take too much time
452      */
453     do
454     {
455         i_done = 1;
456         for( i_index = 1; i_index < p_sub->i_subtitles; i_index++ )
457         {
458             if( p_sub->subtitle[i_index].i_start <
459                     p_sub->subtitle[i_index - 1].i_start )
460             {
461                 subtitle_t sub_xch;
462                 memcpy( &sub_xch, 
463                         p_sub->subtitle + i_index - 1, 
464                         sizeof( subtitle_t ) );
465                 memcpy( p_sub->subtitle + i_index - 1, 
466                         p_sub->subtitle + i_index, 
467                         sizeof( subtitle_t ) );
468                 memcpy( p_sub->subtitle + i_index,
469                         &sub_xch,
470                         sizeof( subtitle_t ) );
471                 i_done = 0;
472             }
473         }
474     } while( !i_done );
475         
476     
477     /* *** and at the end add delay *** */
478     i_delay = (mtime_t)config_GetInt( p_sub, "sub-delay" ) * 100000;
479     if( i_delay != 0 )
480     {
481         for( i = 0; i < p_sub->i_subtitles; i++ )
482         {
483             p_sub->subtitle[i].i_start += i_delay;
484             p_sub->subtitle[i].i_stop += i_delay;
485             if( p_sub->subtitle[i].i_start < 0 )
486             {
487                 p_sub->i_subtitle = i + 1;
488             }
489         }
490     }
491 }
492
493
494
495 /*****************************************************************************
496  * Specific Subtitle function 
497  *****************************************************************************/
498 static int  sub_MicroDvdRead( FILE *p_file, subtitle_t *p_subtitle, mtime_t i_microsecperframe)
499 {
500     /*
501      * each line:
502      *  {n1}{n2}Line1|Line2|Line3....
503      * where n1 and n2 are the video frame number...
504      *
505      */
506     char buffer[MAX_LINE + 1];
507     char buffer_text[MAX_LINE + 1];
508     uint32_t    i_start;
509     uint32_t    i_stop;
510     int         i;
511     
512     for( ;; )
513     {
514         if( fgets( buffer, MAX_LINE, p_file ) <= 0) 
515         {
516             return( -1 );
517         }
518         i_start = 0;
519         i_stop  = 0;
520         if( sscanf( buffer, "{%d}{}%[^\r\n]", &i_start, buffer_text ) == 2 ||
521             sscanf( buffer, "{%d}{%d}%[^\r\n]", &i_start, &i_stop, buffer_text ) == 3)
522         {
523             break;
524         }
525     }
526     /* replace | by \n */
527     for( i = 0; i < MAX_LINE; i++ )
528     {
529         if( buffer_text[i] == '|' )
530         {
531             buffer_text[i] = '\n';
532         }
533     }
534     p_subtitle->i_start = (mtime_t)i_start * (mtime_t)i_microsecperframe;
535     p_subtitle->i_stop  = (mtime_t)i_stop  * (mtime_t)i_microsecperframe;
536     p_subtitle->psz_text = strndup( buffer_text, MAX_LINE );
537     return( 0 );
538 }
539
540 static int  sub_SubRipRead( FILE *p_file, subtitle_t *p_subtitle, mtime_t i_microsecperframe )
541 {
542     /*
543      * n
544      * h1:m1:s1,d1 --> h2:m2:s2,d2
545      * Line1
546      * Line2
547      * ...
548      * [empty line]
549      * 
550      */
551     char buffer[MAX_LINE + 1];
552     char buffer_text[ 10 * MAX_LINE];
553     int  i_buffer_text;
554     mtime_t     i_start;
555     mtime_t     i_stop;
556
557     for( ;; )
558     {
559         int h1, m1, s1, d1, h2, m2, s2, d2;
560         if( fgets( buffer, MAX_LINE, p_file ) <= 0)
561         {
562             return( -1 );
563         }
564         if( sscanf( buffer,
565                     "%d:%d:%d,%d --> %d:%d:%d,%d",
566                     &h1, &m1, &s1, &d1,
567                     &h2, &m2, &s2, &d2 ) == 8 )
568         {
569             i_start = ( (mtime_t)h1 * 3600*1000 + 
570                         (mtime_t)m1 * 60*1000 + 
571                         (mtime_t)s1 * 1000 + 
572                         (mtime_t)d1 ) * 1000;
573
574             i_stop  = ( (mtime_t)h2 * 3600*1000 + 
575                         (mtime_t)m2 * 60*1000 + 
576                         (mtime_t)s2 * 1000 + 
577                         (mtime_t)d2 ) * 1000;
578
579             /* Now read text until an empty line */
580             for( i_buffer_text = 0;; )
581             {
582                 int i_len;
583                 if( fgets( buffer, MAX_LINE, p_file ) <= 0) 
584                 {
585                     return( -1 );
586                 }
587                 buffer[MAX_LINE] = '\0'; // just in case
588                 i_len = strlen( buffer );
589                 if( buffer[0] == '\r' || buffer[0] == '\n' || i_len <= 1 )
590                 {
591                     // empty line -> end of this subtitle
592                     buffer_text[__MAX( i_buffer_text - 1, 0 )] = '\0';
593                     p_subtitle->i_start = i_start;
594                     p_subtitle->i_stop = i_stop;
595                     p_subtitle->psz_text = strdup( buffer_text );
596                     return( 0 );
597                 }
598                 else
599                 {
600                     if( i_buffer_text + i_len + 1 < 10 * MAX_LINE )
601                     {
602                         memcpy( buffer_text + i_buffer_text,
603                                 buffer,
604                                 i_len );
605                         i_buffer_text += i_len;
606
607                         buffer_text[i_buffer_text] = '\n';
608                         i_buffer_text++;
609                     }
610                 }
611             }
612         }
613     }
614    
615 }
616
617
618 static int  sub_SSARead( FILE *p_file, subtitle_t *p_subtitle, mtime_t i_microsecperframe, int i_comma_count )
619 {
620     char buffer[MAX_LINE + 1];
621     char buffer_text[ 10 * MAX_LINE];
622     char *p_buffer_text;
623     mtime_t     i_start;
624     mtime_t     i_stop;
625     int         i_comma;
626     int         i_text;
627     
628     for( ;; )
629     {
630         int h1, m1, s1, c1, h2, m2, s2, c2;
631         int i_dummy;
632         if( fgets( buffer, MAX_LINE, p_file ) <= 0) 
633         {
634             return( -1 );
635         }
636         if( sscanf( buffer, 
637                     "Dialogue: Marked=%d,%d:%d:%d.%d,%d:%d:%d.%d,%[^\r\n]",
638                     &i_dummy, 
639                     &h1, &m1, &s1, &c1,
640                     &h2, &m2, &s2, &c2,
641                     buffer_text ) == 10 )
642         {
643             i_start = ( (mtime_t)h1 * 3600*1000 + 
644                         (mtime_t)m1 * 60*1000 + 
645                         (mtime_t)s1 * 1000 + 
646                         (mtime_t)c1 * 10 ) * 1000;
647
648             i_stop  = ( (mtime_t)h2 * 3600*1000 + 
649                         (mtime_t)m2 * 60*1000 + 
650                         (mtime_t)s2 * 1000 + 
651                         (mtime_t)c2 * 10 ) * 1000;
652             
653             p_buffer_text = buffer_text;
654             i_comma = 3;
655             while( i_comma < i_comma_count && 
656                    *p_buffer_text != '\0' )
657             {   
658                 if( *p_buffer_text == ',' )
659                 {
660                     i_comma++;
661                 }
662                 p_buffer_text++;
663             }
664             p_subtitle->psz_text = malloc( strlen( p_buffer_text ) + 1);
665             i_text = 0;
666             while( *p_buffer_text )
667             {
668                 if( *p_buffer_text == '\\' && ( *p_buffer_text =='n' || *p_buffer_text =='N' ) )
669                 {
670                     p_subtitle->psz_text[i_text] = '\n';
671                     i_text++;
672                     p_buffer_text += 2;
673                 }
674                 else if( *p_buffer_text == '{' && *p_buffer_text == '\\')
675                 {
676                     while( *p_buffer_text && *p_buffer_text != '}' )
677                     {
678                         p_buffer_text++;
679                     }
680                 }
681                 else
682                 {
683                     p_subtitle->psz_text[i_text] = *p_buffer_text;
684                     i_text++;
685                     p_buffer_text++;
686                 }
687             }
688             p_subtitle->psz_text[i_text] = '\0';
689             p_subtitle->i_start = i_start;
690             p_subtitle->i_stop = i_stop;
691             return( 0 );
692         }
693     }
694 }
695
696 static int  sub_SSA1Read( FILE *p_file, subtitle_t *p_subtitle, mtime_t i_microsecperframe )
697 {
698     return( sub_SSARead( p_file, p_subtitle, i_microsecperframe, 8 ) );
699 }
700 static int  sub_SSA2_4Read( FILE *p_file, subtitle_t *p_subtitle, mtime_t i_microsecperframe )
701 {
702     return( sub_SSARead( p_file, p_subtitle, i_microsecperframe, 9 ) );
703 }
704