?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
demux: adaptive: remove left indirect returns since lock removal
[vlc.git] / modules / demux / subtitle.c
blobf117bda2b76e9e72e3e98a70b547df98169bce5d
1 /*****************************************************************************
2 * subtitle.c: Demux for subtitle text files.
3 *****************************************************************************
4 * Copyright (C) 1999-2007 VLC authors and VideoLAN
5 *
6 * Authors: Laurent Aimar <fenrir@via.ecp.fr>
7 * Derk-Jan Hartman <hartman at videolan dot org>
8 * Jean-Baptiste Kempf <jb@videolan.org>
9 *
10 * This program is free software; you can redistribute it and/or modify it
11 * under the terms of the GNU Lesser General Public License as published by
12 * the Free Software Foundation; either version 2.1 of the License, or
13 * (at your option) any later version.
14 *
15 * This program is distributed in the hope that it will be useful,
16 * but WITHOUT ANY WARRANTY; without even the implied warranty of
17 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
18 * GNU Lesser General Public License for more details.
19 *
20 * You should have received a copy of the GNU Lesser General Public License
21 * along with this program; if not, write to the Free Software Foundation,
22 * Inc., 51 Franklin Street, Fifth Floor, Boston MA 02110-1301, USA.
23 *****************************************************************************/
24
25 /*****************************************************************************
26 * Preamble
27 *****************************************************************************/
28
29 #ifdef HAVE_CONFIG_H
30 # include "config.h"
31 #endif
32
33 #include <vlc_common.h>
34 #include <vlc_plugin.h>
35
36 #include <ctype.h>
37 #include <math.h>
38 #include <assert.h>
39
40 #include <vlc_demux.h>
41 #include <vlc_charset.h>
42
43 /*****************************************************************************
44 * Module descriptor
45 *****************************************************************************/
46 static int Open ( vlc_object_t *p_this );
47 static void Close( vlc_object_t *p_this );
48
49 #define SUB_TYPE_LONGTEXT \
50 N_("Force the subtiles format. Selecting \"auto\" means autodetection and should always work.")
51 #define SUB_DESCRIPTION_LONGTEXT \
52 N_("Override the default track description.")
53
54 static const char *const ppsz_sub_type[] =
55 {
56 "auto", "microdvd", "subrip", "subviewer", "ssa1",
57 "ssa2-4", "ass", "vplayer", "sami", "dvdsubtitle", "mpl2",
58 "aqt", "pjs", "mpsub", "jacosub", "psb", "realtext", "dks",
59 "subviewer1", "sbv"
60 };
61
62 vlc_module_begin ()
63 set_shortname( N_("Subtitles"))
64 set_description( N_("Text subtitle parser") )
65 set_capability( "demux", 0 )
66 set_category( CAT_INPUT )
67 set_subcategory( SUBCAT_INPUT_DEMUX )
68 add_string( "sub-type", "auto", N_("Subtitle format"),
69 SUB_TYPE_LONGTEXT, true )
70 change_string_list( ppsz_sub_type, ppsz_sub_type )
71 add_string( "sub-description", NULL, N_("Subtitle description"),
72 SUB_DESCRIPTION_LONGTEXT, true )
73 set_callbacks( Open, Close )
74
75 add_shortcut( "subtitle" )
76 vlc_module_end ()
77
78 /*****************************************************************************
79 * Prototypes:
80 *****************************************************************************/
81 enum subtitle_type_e
82 {
83 SUB_TYPE_UNKNOWN = -1,
84 SUB_TYPE_MICRODVD,
85 SUB_TYPE_SUBRIP,
86 SUB_TYPE_SSA1,
87 SUB_TYPE_SSA2_4,
88 SUB_TYPE_ASS,
89 SUB_TYPE_VPLAYER,
90 SUB_TYPE_SAMI,
91 SUB_TYPE_SUBVIEWER, /* SUBVIEWER 2 */
92 SUB_TYPE_DVDSUBTITLE, /* Mplayer calls it subviewer2 */
93 SUB_TYPE_MPL2,
94 SUB_TYPE_AQT,
95 SUB_TYPE_PJS,
96 SUB_TYPE_MPSUB,
97 SUB_TYPE_JACOSUB,
98 SUB_TYPE_PSB,
99 SUB_TYPE_RT,
100 SUB_TYPE_DKS,
101 SUB_TYPE_SUBVIEW1, /* SUBVIEWER 1 - mplayer calls it subrip09,
102 and Gnome subtitles SubViewer 1.0 */
103 SUB_TYPE_SBV,
104 SUB_TYPE_SCC, /* Scenarist Closed Caption */
105 };
106
107 typedef struct
108 {
109 size_t i_line_count;
110 size_t i_line;
111 char **line;
112 } text_t;
113
114 static int TextLoad( text_t *, stream_t *s );
115 static void TextUnload( text_t * );
116
117 typedef struct
118 {
119 vlc_tick_t i_start;
120 vlc_tick_t i_stop;
121
122 char *psz_text;
123 } subtitle_t;
124
125 typedef struct
126 {
127 enum subtitle_type_e i_type;
128 vlc_tick_t i_microsecperframe;
129
130 char *psz_header; /* SSA */
131
132 struct
133 {
134 bool b_inited;
135
136 int i_comment;
137 int i_time_resolution;
138 int i_time_shift;
139 } jss;
140
141 struct
142 {
143 bool b_inited;
144
145 float f_total;
146 int i_factor;
147 } mpsub;
148
149 struct
150 {
151 const char *psz_start;
152 } sami;
153
154 } subs_properties_t;
155
156 typedef struct
157 {
158 es_out_id_t *es;
159 bool b_slave;
160 bool b_first_time;
161
162 double f_rate;
163 vlc_tick_t i_next_demux_date;
164
165 struct
166 {
167 subtitle_t *p_array;
168 size_t i_count;
169 size_t i_current;
170 } subtitles;
171
172 vlc_tick_t i_length;
173
174 /* */
175 subs_properties_t props;
176
177 block_t * (*pf_convert)( const subtitle_t * );
178 } demux_sys_t;
179
180 static int ParseMicroDvd ( vlc_object_t *, subs_properties_t *, text_t *, subtitle_t *, size_t );
181 static int ParseSubRip ( vlc_object_t *, subs_properties_t *, text_t *, subtitle_t *, size_t );
182 static int ParseSubViewer ( vlc_object_t *, subs_properties_t *, text_t *, subtitle_t *, size_t );
183 static int ParseSSA ( vlc_object_t *, subs_properties_t *, text_t *, subtitle_t *, size_t );
184 static int ParseVplayer ( vlc_object_t *, subs_properties_t *, text_t *, subtitle_t *, size_t );
185 static int ParseSami ( vlc_object_t *, subs_properties_t *, text_t *, subtitle_t *, size_t );
186 static int ParseDVDSubtitle( vlc_object_t *, subs_properties_t *, text_t *, subtitle_t *, size_t );
187 static int ParseMPL2 ( vlc_object_t *, subs_properties_t *, text_t *, subtitle_t *, size_t );
188 static int ParseAQT ( vlc_object_t *, subs_properties_t *, text_t *, subtitle_t *, size_t );
189 static int ParsePJS ( vlc_object_t *, subs_properties_t *, text_t *, subtitle_t *, size_t );
190 static int ParseMPSub ( vlc_object_t *, subs_properties_t *, text_t *, subtitle_t *, size_t );
191 static int ParseJSS ( vlc_object_t *, subs_properties_t *, text_t *, subtitle_t *, size_t );
192 static int ParsePSB ( vlc_object_t *, subs_properties_t *, text_t *, subtitle_t *, size_t );
193 static int ParseRealText ( vlc_object_t *, subs_properties_t *, text_t *, subtitle_t *, size_t );
194 static int ParseDKS ( vlc_object_t *, subs_properties_t *, text_t *, subtitle_t *, size_t );
195 static int ParseSubViewer1 ( vlc_object_t *, subs_properties_t *, text_t *, subtitle_t *, size_t );
196 static int ParseCommonSBV ( vlc_object_t *, subs_properties_t *, text_t *, subtitle_t *, size_t );
197 static int ParseSCC ( vlc_object_t *, subs_properties_t *, text_t *, subtitle_t *, size_t );
198
199 static const struct
200 {
201 const char *psz_type_name;
202 int i_type;
203 const char *psz_name;
204 int (*pf_read)( vlc_object_t *, subs_properties_t *, text_t *, subtitle_t*, size_t );
205 } sub_read_subtitle_function [] =
206 {
207 { "microdvd", SUB_TYPE_MICRODVD, "MicroDVD", ParseMicroDvd },
208 { "subrip", SUB_TYPE_SUBRIP, "SubRIP", ParseSubRip },
209 { "subviewer", SUB_TYPE_SUBVIEWER, "SubViewer", ParseSubViewer },
210 { "ssa1", SUB_TYPE_SSA1, "SSA-1", ParseSSA },
211 { "ssa2-4", SUB_TYPE_SSA2_4, "SSA-2/3/4", ParseSSA },
212 { "ass", SUB_TYPE_ASS, "SSA/ASS", ParseSSA },
213 { "vplayer", SUB_TYPE_VPLAYER, "VPlayer", ParseVplayer },
214 { "sami", SUB_TYPE_SAMI, "SAMI", ParseSami },
215 { "dvdsubtitle",SUB_TYPE_DVDSUBTITLE, "DVDSubtitle", ParseDVDSubtitle },
216 { "mpl2", SUB_TYPE_MPL2, "MPL2", ParseMPL2 },
217 { "aqt", SUB_TYPE_AQT, "AQTitle", ParseAQT },
218 { "pjs", SUB_TYPE_PJS, "PhoenixSub", ParsePJS },
219 { "mpsub", SUB_TYPE_MPSUB, "MPSub", ParseMPSub },
220 { "jacosub", SUB_TYPE_JACOSUB, "JacoSub", ParseJSS },
221 { "psb", SUB_TYPE_PSB, "PowerDivx", ParsePSB },
222 { "realtext", SUB_TYPE_RT, "RealText", ParseRealText },
223 { "dks", SUB_TYPE_DKS, "DKS", ParseDKS },
224 { "subviewer1", SUB_TYPE_SUBVIEW1, "Subviewer 1", ParseSubViewer1 },
225 { "sbv", SUB_TYPE_SBV, "SBV", ParseCommonSBV },
226 { "scc", SUB_TYPE_SCC, "SCC", ParseSCC },
227 { NULL, SUB_TYPE_UNKNOWN, "Unknown", NULL }
228 };
229 /* When adding support for more formats, be sure to add their file extension
230 * to src/input/subtitles.c to enable auto-detection.
231 */
232
233 static int Demux( demux_t * );
234 static int Control( demux_t *, int, va_list );
235
236 static void Fix( demux_t * );
237 static char * get_language_from_filename( const char * );
238
239 /*****************************************************************************
240 * Decoder format output function
241 *****************************************************************************/
242
243 static block_t *ToTextBlock( const subtitle_t *p_subtitle )
244 {
245 block_t *p_block;
246 size_t i_len = strlen( p_subtitle->psz_text ) + 1;
247
248 if( i_len <= 1 || !(p_block = block_Alloc( i_len )) )
249 return NULL;
250
251 memcpy( p_block->p_buffer, p_subtitle->psz_text, i_len );
252
253 return p_block;
254 }
255
256 static block_t *ToEIA608Block( const subtitle_t *p_subtitle )
257 {
258 block_t *p_block;
259 const size_t i_len = strlen( p_subtitle->psz_text );
260 const size_t i_block = (1 + i_len / 5) * 3;
261
262 if( i_len < 4 || !(p_block = block_Alloc( i_block )) )
263 return NULL;
264
265 p_block->i_buffer = 0;
266
267 char *saveptr = NULL;
268 char *psz_tok = strtok_r( p_subtitle->psz_text, " ", &saveptr );
269 unsigned a, b;
270 while( psz_tok &&
271 sscanf( psz_tok, "%2x%2x", &a, &b ) == 2 &&
272 i_block - p_block->i_buffer >= 3 )
273 {
274 uint8_t *p_data = &p_block->p_buffer[p_block->i_buffer];
275 p_data[0] = 0xFC;
276 p_data[1] = a;
277 p_data[2] = b;
278 p_block->i_buffer += 3;
279 psz_tok = strtok_r( NULL, " ", &saveptr );
280 }
281
282 return p_block;
283 }
284
285 /*****************************************************************************
286 * Module initializer
287 *****************************************************************************/
288 static int Open ( vlc_object_t *p_this )
289 {
290 demux_t *p_demux = (demux_t*)p_this;
291 demux_sys_t *p_sys;
292 es_format_t fmt;
293 float f_fps;
294 char *psz_type;
295 int (*pf_read)( vlc_object_t *, subs_properties_t *, text_t *, subtitle_t*, size_t );
296
297 if( !p_demux->obj.force )
298 {
299 msg_Dbg( p_demux, "subtitle demux discarded" );
300 return VLC_EGENERIC;
301 }
302
303 p_demux->pf_demux = Demux;
304 p_demux->pf_control = Control;
305 p_demux->p_sys = p_sys = malloc( sizeof( demux_sys_t ) );
306 if( p_sys == NULL )
307 return VLC_ENOMEM;
308
309 p_sys->b_slave = false;
310 p_sys->b_first_time = true;
311 p_sys->i_next_demux_date = 0;
312 p_sys->f_rate = 1.0;
313
314 p_sys->pf_convert = ToTextBlock;
315
316 p_sys->subtitles.i_current= 0;
317 p_sys->subtitles.i_count = 0;
318 p_sys->subtitles.p_array = NULL;
319
320 p_sys->props.psz_header = NULL;
321 p_sys->props.i_microsecperframe = VLC_TICK_FROM_MS(40);
322 p_sys->props.jss.b_inited = false;
323 p_sys->props.mpsub.b_inited = false;
324 p_sys->props.sami.psz_start = NULL;
325
326 /* Get the FPS */
327 f_fps = var_CreateGetFloat( p_demux, "sub-original-fps" );
328 if( f_fps >= 1.f )
329 {
330 p_sys->props.i_microsecperframe = llroundf( (float)CLOCK_FREQ / f_fps );
331 msg_Dbg( p_demux, "Override subtitle fps %f", (double) f_fps );
332 }
333
334 /* Get or probe the type */
335 p_sys->props.i_type = SUB_TYPE_UNKNOWN;
336 psz_type = var_CreateGetString( p_demux, "sub-type" );
337 if( psz_type && *psz_type )
338 {
339 for( int i = 0; ; i++ )
340 {
341 if( sub_read_subtitle_function[i].psz_type_name == NULL )
342 break;
343
344 if( !strcmp( sub_read_subtitle_function[i].psz_type_name,
345 psz_type ) )
346 {
347 p_sys->props.i_type = sub_read_subtitle_function[i].i_type;
348 break;
349 }
350 }
351 }
352 free( psz_type );
353
354 #ifndef NDEBUG
355 const uint64_t i_start_pos = vlc_stream_Tell( p_demux->s );
356 #endif
357
358 size_t i_peek;
359 const uint8_t *p_peek;
360 if( vlc_stream_Peek( p_demux->s, &p_peek, 16 ) < 16 )
361 {
362 free( p_sys );
363 return VLC_EGENERIC;
364 }
365
366 enum
367 {
368 UTF8BOM,
369 UTF16LE,
370 UTF16BE,
371 NOBOM,
372 } e_bom = NOBOM;
373 const char *psz_bom = NULL;
374
375 i_peek = 4096;
376 /* Detect Unicode while skipping the UTF-8 Byte Order Mark */
377 if( !memcmp( p_peek, "\xEF\xBB\xBF", 3 ) )
378 {
379 e_bom = UTF8BOM;
380 psz_bom = "UTF-8";
381 }
382 else if( !memcmp( p_peek, "\xFF\xFE", 2 ) )
383 {
384 e_bom = UTF16LE;
385 psz_bom = "UTF-16LE";
386 i_peek *= 2;
387 }
388 else if( !memcmp( p_peek, "\xFE\xFF", 2 ) )
389 {
390 e_bom = UTF16BE;
391 psz_bom = "UTF-16BE";
392 i_peek *= 2;
393 }
394
395 if( e_bom != NOBOM )
396 msg_Dbg( p_demux, "detected %s Byte Order Mark", psz_bom );
397
398 i_peek = vlc_stream_Peek( p_demux->s, &p_peek, i_peek );
399 if( unlikely(i_peek < 16) )
400 {
401 free( p_sys );
402 return VLC_EGENERIC;
403 }
404
405 stream_t *p_probestream = NULL;
406 if( e_bom != UTF8BOM && e_bom != NOBOM )
407 {
408 if( i_peek > 16 )
409 {
410 char *p_outbuf = FromCharset( psz_bom, p_peek, i_peek );
411 if( p_outbuf != NULL )
412 p_probestream = vlc_stream_MemoryNew( p_demux, (uint8_t *)p_outbuf,
413 strlen( p_outbuf ),
414 false ); /* free p_outbuf on release */
415 }
416 }
417 else
418 {
419 const size_t i_skip = (e_bom == UTF8BOM) ? 3 : 0;
420 p_probestream = vlc_stream_MemoryNew( p_demux, (uint8_t *) &p_peek[i_skip],
421 i_peek - i_skip, true );
422 }
423
424 if( p_probestream == NULL )
425 {
426 free( p_sys );
427 return VLC_EGENERIC;
428 }
429
430 /* Probe if unknown type */
431 if( p_sys->props.i_type == SUB_TYPE_UNKNOWN )
432 {
433 int i_try;
434 char *s = NULL;
435
436 msg_Dbg( p_demux, "autodetecting subtitle format" );
437 for( i_try = 0; i_try < 256; i_try++ )
438 {
439 int i_dummy;
440 char p_dummy;
441
442 if( (s = vlc_stream_ReadLine( p_probestream ) ) == NULL )
443 break;
444
445 if( strcasestr( s, "<SAMI>" ) )
446 {
447 p_sys->props.i_type = SUB_TYPE_SAMI;
448 break;
449 }
450 else if( sscanf( s, "{%d}{%d}", &i_dummy, &i_dummy ) == 2 ||
451 sscanf( s, "{%d}{}", &i_dummy ) == 1)
452 {
453 p_sys->props.i_type = SUB_TYPE_MICRODVD;
454 break;
455 }
456 else if( sscanf( s, "%d:%d:%d,%d --> %d:%d:%d,%d",
457 &i_dummy,&i_dummy,&i_dummy,&i_dummy,
458 &i_dummy,&i_dummy,&i_dummy,&i_dummy ) == 8 ||
459 sscanf( s, "%d:%d:%d --> %d:%d:%d,%d",
460 &i_dummy,&i_dummy,&i_dummy,&i_dummy,
461 &i_dummy,&i_dummy,&i_dummy ) == 7 ||
462 sscanf( s, "%d:%d:%d,%d --> %d:%d:%d",
463 &i_dummy,&i_dummy,&i_dummy,&i_dummy,
464 &i_dummy,&i_dummy,&i_dummy ) == 7 ||
465 sscanf( s, "%d:%d:%d.%d --> %d:%d:%d.%d",
466 &i_dummy,&i_dummy,&i_dummy,&i_dummy,
467 &i_dummy,&i_dummy,&i_dummy,&i_dummy ) == 8 ||
468 sscanf( s, "%d:%d:%d --> %d:%d:%d.%d",
469 &i_dummy,&i_dummy,&i_dummy,&i_dummy,
470 &i_dummy,&i_dummy,&i_dummy ) == 7 ||
471 sscanf( s, "%d:%d:%d.%d --> %d:%d:%d",
472 &i_dummy,&i_dummy,&i_dummy,&i_dummy,
473 &i_dummy,&i_dummy,&i_dummy ) == 7 ||
474 sscanf( s, "%d:%d:%d --> %d:%d:%d",
475 &i_dummy,&i_dummy,&i_dummy,
476 &i_dummy,&i_dummy,&i_dummy ) == 6 )
477 {
478 p_sys->props.i_type = SUB_TYPE_SUBRIP;
479 break;
480 }
481 else if( !strncasecmp( s, "!: This is a Sub Station Alpha v1", 33 ) )
482 {
483 p_sys->props.i_type = SUB_TYPE_SSA1;
484 break;
485 }
486 else if( !strncasecmp( s, "ScriptType: v4.00+", 18 ) )
487 {
488 p_sys->props.i_type = SUB_TYPE_ASS;
489 break;
490 }
491 else if( !strncasecmp( s, "ScriptType: v4.00", 17 ) )
492 {
493 p_sys->props.i_type = SUB_TYPE_SSA2_4;
494 break;
495 }
496 else if( !strncasecmp( s, "Dialogue: Marked", 16 ) )
497 {
498 p_sys->props.i_type = SUB_TYPE_SSA2_4;
499 break;
500 }
501 else if( !strncasecmp( s, "Dialogue:", 9 ) )
502 {
503 p_sys->props.i_type = SUB_TYPE_ASS;
504 break;
505 }
506 else if( strcasestr( s, "[INFORMATION]" ) )
507 {
508 p_sys->props.i_type = SUB_TYPE_SUBVIEWER; /* I hope this will work */
509 break;
510 }
511 else if( sscanf( s, "%d:%d:%d.%d %d:%d:%d",
512 &i_dummy, &i_dummy, &i_dummy, &i_dummy,
513 &i_dummy, &i_dummy, &i_dummy ) == 7 ||
514 sscanf( s, "@%d @%d", &i_dummy, &i_dummy) == 2)
515 {
516 p_sys->props.i_type = SUB_TYPE_JACOSUB;
517 break;
518 }
519 else if( sscanf( s, "%d:%d:%d.%d,%d:%d:%d.%d",
520 &i_dummy, &i_dummy, &i_dummy, &i_dummy,
521 &i_dummy, &i_dummy, &i_dummy, &i_dummy ) == 8 )
522 {
523 p_sys->props.i_type = SUB_TYPE_SBV;
524 break;
525 }
526 else if( sscanf( s, "%d:%d:%d:", &i_dummy, &i_dummy, &i_dummy ) == 3 ||
527 sscanf( s, "%d:%d:%d ", &i_dummy, &i_dummy, &i_dummy ) == 3 )
528 {
529 p_sys->props.i_type = SUB_TYPE_VPLAYER;
530 break;
531 }
532 else if( sscanf( s, "{T %d:%d:%d:%d", &i_dummy, &i_dummy,
533 &i_dummy, &i_dummy ) == 4 )
534 {
535 p_sys->props.i_type = SUB_TYPE_DVDSUBTITLE;
536 break;
537 }
538 else if( sscanf( s, "[%d:%d:%d]%c",
539 &i_dummy, &i_dummy, &i_dummy, &p_dummy ) == 4 )
540 {
541 p_sys->props.i_type = SUB_TYPE_DKS;
542 break;
543 }
544 else if( strstr( s, "*** START SCRIPT" ) )
545 {
546 p_sys->props.i_type = SUB_TYPE_SUBVIEW1;
547 break;
548 }
549 else if( sscanf( s, "[%d][%d]", &i_dummy, &i_dummy ) == 2 ||
550 sscanf( s, "[%d][]", &i_dummy ) == 1)
551 {
552 p_sys->props.i_type = SUB_TYPE_MPL2;
553 break;
554 }
555 else if( sscanf (s, "FORMAT=%d", &i_dummy) == 1 ||
556 ( sscanf (s, "FORMAT=TIM%c", &p_dummy) == 1
557 && p_dummy =='E' ) )
558 {
559 p_sys->props.i_type = SUB_TYPE_MPSUB;
560 break;
561 }
562 else if( sscanf( s, "-->> %d", &i_dummy) == 1 )
563 {
564 p_sys->props.i_type = SUB_TYPE_AQT;
565 break;
566 }
567 else if( sscanf( s, "%d,%d,", &i_dummy, &i_dummy ) == 2 )
568 {
569 p_sys->props.i_type = SUB_TYPE_PJS;
570 break;
571 }
572 else if( sscanf( s, "{%d:%d:%d}",
573 &i_dummy, &i_dummy, &i_dummy ) == 3 )
574 {
575 p_sys->props.i_type = SUB_TYPE_PSB;
576 break;
577 }
578 else if( strcasestr( s, "<time" ) )
579 {
580 p_sys->props.i_type = SUB_TYPE_RT;
581 break;
582 }
583 else if( !strncasecmp( s, "WEBVTT",6 ) )
584 {
585 /* FAIL */
586 break;
587 }
588 else if( !strncasecmp( s, "Scenarist_SCC V1.0", 18 ) )
589 {
590 p_sys->props.i_type = SUB_TYPE_SCC;
591 p_sys->pf_convert = ToEIA608Block;
592 break;
593 }
594
595 free( s );
596 s = NULL;
597 }
598
599 free( s );
600 }
601
602 vlc_stream_Delete( p_probestream );
603
604 /* Quit on unknown subtitles */
605 if( p_sys->props.i_type == SUB_TYPE_UNKNOWN )
606 {
607 #ifndef NDEBUG
608 /* Ensure it will work with non seekable streams */
609 assert( i_start_pos == vlc_stream_Tell( p_demux->s ) );
610 #endif
611 msg_Warn( p_demux, "failed to recognize subtitle type" );
612 free( p_sys );
613 return VLC_EGENERIC;
614 }
615
616 for( int i = 0; ; i++ )
617 {
618 if( sub_read_subtitle_function[i].i_type == p_sys->props.i_type )
619 {
620 msg_Dbg( p_demux, "detected %s format",
621 sub_read_subtitle_function[i].psz_name );
622 pf_read = sub_read_subtitle_function[i].pf_read;
623 break;
624 }
625 }
626
627 msg_Dbg( p_demux, "loading all subtitles..." );
628
629 if( e_bom == UTF8BOM && /* skip BOM */
630 vlc_stream_Read( p_demux->s, NULL, 3 ) != 3 )
631 {
632 Close( p_this );
633 return VLC_EGENERIC;
634 }
635
636 /* Load the whole file */
637 text_t txtlines;
638 TextLoad( &txtlines, p_demux->s );
639
640 /* Parse it */
641 for( size_t i_max = 0; i_max < SIZE_MAX - 500 * sizeof(subtitle_t); )
642 {
643 if( p_sys->subtitles.i_count >= i_max )
644 {
645 i_max += 500;
646 subtitle_t *p_realloc = realloc( p_sys->subtitles.p_array, sizeof(subtitle_t) * i_max );
647 if( p_realloc == NULL )
648 {
649 TextUnload( &txtlines );
650 Close( p_this );
651 return VLC_ENOMEM;
652 }
653 p_sys->subtitles.p_array = p_realloc;
654 }
655
656 if( pf_read( VLC_OBJECT(p_demux), &p_sys->props, &txtlines,
657 &p_sys->subtitles.p_array[p_sys->subtitles.i_count],
658 p_sys->subtitles.i_count ) )
659 break;
660
661 p_sys->subtitles.i_count++;
662 }
663 /* Unload */
664 TextUnload( &txtlines );
665
666 msg_Dbg(p_demux, "loaded %zu subtitles", p_sys->subtitles.i_count );
667
668 /* *** add subtitle ES *** */
669 if( p_sys->props.i_type == SUB_TYPE_SSA1 ||
670 p_sys->props.i_type == SUB_TYPE_SSA2_4 ||
671 p_sys->props.i_type == SUB_TYPE_ASS )
672 {
673 Fix( p_demux );
674 es_format_Init( &fmt, SPU_ES, VLC_CODEC_SSA );
675 }
676 else if( p_sys->props.i_type == SUB_TYPE_SCC )
677 {
678 es_format_Init( &fmt, SPU_ES, VLC_CODEC_CEA608 );
679 fmt.subs.cc.i_reorder_depth = -1;
680 }
681 else
682 es_format_Init( &fmt, SPU_ES, VLC_CODEC_SUBT );
683
684 p_sys->subtitles.i_current = 0;
685 p_sys->i_length = 0;
686 if( p_sys->subtitles.i_count > 0 )
687 p_sys->i_length = p_sys->subtitles.p_array[p_sys->subtitles.i_count-1].i_stop;
688
689 /* Stupid language detection in the filename */
690 char * psz_language = get_language_from_filename( p_demux->psz_filepath );
691
692 if( psz_language )
693 {
694 fmt.psz_language = psz_language;
695 msg_Dbg( p_demux, "detected language %s of subtitle: %s", psz_language,
696 p_demux->psz_location );
697 }
698
699 char *psz_description = var_InheritString( p_demux, "sub-description" );
700 if( psz_description && *psz_description )
701 fmt.psz_description = psz_description;
702 else
703 free( psz_description );
704 if( p_sys->props.psz_header != NULL &&
705 (fmt.p_extra = strdup( p_sys->props.psz_header )) )
706 {
707 fmt.i_extra = strlen( p_sys->props.psz_header ) + 1;
708 }
709
710 fmt.i_id = 0;
711 p_sys->es = es_out_Add( p_demux->out, &fmt );
712 es_format_Clean( &fmt );
713 if( p_sys->es == NULL )
714 {
715 Close( p_this );
716 return VLC_EGENERIC;
717 }
718
719 return VLC_SUCCESS;
720 }
721
722 /*****************************************************************************
723 * Close: Close subtitle demux
724 *****************************************************************************/
725 static void Close( vlc_object_t *p_this )
726 {
727 demux_t *p_demux = (demux_t*)p_this;
728 demux_sys_t *p_sys = p_demux->p_sys;
729
730 for( size_t i = 0; i < p_sys->subtitles.i_count; i++ )
731 free( p_sys->subtitles.p_array[i].psz_text );
732 free( p_sys->subtitles.p_array );
733 free( p_sys->props.psz_header );
734
735 free( p_sys );
736 }
737
738 static void
739 ResetCurrentIndex( demux_t *p_demux )
740 {
741 demux_sys_t *p_sys = p_demux->p_sys;
742 for( size_t i = 0; i < p_sys->subtitles.i_count; i++ )
743 {
744 if( p_sys->subtitles.p_array[i].i_start * p_sys->f_rate >
745 p_sys->i_next_demux_date && i > 0 )
746 break;
747 p_sys->subtitles.i_current = i;
748 }
749 }
750
751 /*****************************************************************************
752 * Control:
753 *****************************************************************************/
754 static int Control( demux_t *p_demux, int i_query, va_list args )
755 {
756 demux_sys_t *p_sys = p_demux->p_sys;
757 double *pf, f;
758
759 switch( i_query )
760 {
761 case DEMUX_CAN_SEEK:
762 *va_arg( args, bool * ) = true;
763 return VLC_SUCCESS;
764
765 case DEMUX_GET_LENGTH:
766 *va_arg( args, vlc_tick_t * ) = p_sys->i_length;
767 return VLC_SUCCESS;
768
769 case DEMUX_GET_TIME:
770 *va_arg( args, vlc_tick_t * ) = p_sys->i_next_demux_date;
771 return VLC_SUCCESS;
772
773 case DEMUX_SET_TIME:
774 {
775 p_sys->b_first_time = true;
776 p_sys->i_next_demux_date = va_arg( args, vlc_tick_t );
777 ResetCurrentIndex( p_demux );
778 return VLC_SUCCESS;
779 }
780
781 case DEMUX_GET_POSITION:
782 pf = va_arg( args, double * );
783 if( p_sys->subtitles.i_current >= p_sys->subtitles.i_count )
784 {
785 *pf = 1.0;
786 }
787 else if( p_sys->subtitles.i_count > 0 && p_sys->i_length )
788 {
789 *pf = p_sys->i_next_demux_date;
790 *pf /= p_sys->i_length;
791 }
792 else
793 {
794 *pf = 0.0;
795 }
796 return VLC_SUCCESS;
797
798 case DEMUX_SET_POSITION:
799 f = va_arg( args, double );
800 if( p_sys->subtitles.i_count && p_sys->i_length )
801 {
802 vlc_tick_t i64 = VLC_TICK_0 + f * p_sys->i_length;
803 return demux_Control( p_demux, DEMUX_SET_TIME, i64 );
804 }
805 break;
806
807 case DEMUX_CAN_CONTROL_RATE:
808 *va_arg( args, bool * ) = true;
809 return VLC_SUCCESS;
810 case DEMUX_SET_RATE:
811 p_sys->f_rate = *va_arg( args, float * );
812 ResetCurrentIndex( p_demux );
813 return VLC_SUCCESS;
814 case DEMUX_SET_NEXT_DEMUX_TIME:
815 p_sys->b_slave = true;
816 p_sys->i_next_demux_date = va_arg( args, vlc_tick_t ) - VLC_TICK_0;
817 return VLC_SUCCESS;
818
819 case DEMUX_CAN_PAUSE:
820 case DEMUX_SET_PAUSE_STATE:
821 case DEMUX_CAN_CONTROL_PACE:
822 return demux_vaControlHelper( p_demux->s, 0, -1, 0, 1, i_query, args );
823
824 case DEMUX_GET_PTS_DELAY:
825 case DEMUX_GET_FPS:
826 case DEMUX_GET_META:
827 case DEMUX_GET_ATTACHMENTS:
828 case DEMUX_GET_TITLE_INFO:
829 case DEMUX_HAS_UNSUPPORTED_META:
830 case DEMUX_CAN_RECORD:
831 default:
832 break;
833
834 }
835 return VLC_EGENERIC;
836 }
837
838 /*****************************************************************************
839 * Demux: Send subtitle to decoder
840 *****************************************************************************/
841 static int Demux( demux_t *p_demux )
842 {
843 demux_sys_t *p_sys = p_demux->p_sys;
844
845 vlc_tick_t i_barrier = p_sys->i_next_demux_date;
846
847 while( p_sys->subtitles.i_current < p_sys->subtitles.i_count &&
848 ( p_sys->subtitles.p_array[p_sys->subtitles.i_current].i_start *
849 p_sys->f_rate ) <= i_barrier )
850 {
851 const subtitle_t *p_subtitle = &p_sys->subtitles.p_array[p_sys->subtitles.i_current];
852
853 if ( !p_sys->b_slave && p_sys->b_first_time )
854 {
855 es_out_SetPCR( p_demux->out, VLC_TICK_0 + i_barrier );
856 p_sys->b_first_time = false;
857 }
858
859 if( p_subtitle->i_start >= 0 )
860 {
861 block_t *p_block = p_sys->pf_convert( p_subtitle );
862 if( p_block )
863 {
864 p_block->i_dts =
865 p_block->i_pts = VLC_TICK_0 + p_subtitle->i_start * p_sys->f_rate;
866 if( p_subtitle->i_stop >= 0 && p_subtitle->i_stop >= p_subtitle->i_start )
867 p_block->i_length = (p_subtitle->i_stop - p_subtitle->i_start) * p_sys->f_rate;
868
869 es_out_Send( p_demux->out, p_sys->es, p_block );
870 }
871 }
872
873 p_sys->subtitles.i_current++;
874 }
875
876 if ( !p_sys->b_slave )
877 {
878 es_out_SetPCR( p_demux->out, VLC_TICK_0 + i_barrier );
879 p_sys->i_next_demux_date += VLC_TICK_FROM_MS(125);
880 }
881
882 if( p_sys->subtitles.i_current >= p_sys->subtitles.i_count )
883 return VLC_DEMUXER_EOF;
884
885 return VLC_DEMUXER_SUCCESS;
886 }
887
888
889 static int subtitle_cmp( const void *first, const void *second )
890 {
891 vlc_tick_t result = ((subtitle_t *)(first))->i_start - ((subtitle_t *)(second))->i_start;
892 /* Return -1, 0 ,1, and not directly subtraction
893 * as result can be > INT_MAX */
894 return result == 0 ? 0 : result > 0 ? 1 : -1;
895 }
896 /*****************************************************************************
897 * Fix: fix time stamp and order of subtitle
898 *****************************************************************************/
899 static void Fix( demux_t *p_demux )
900 {
901 demux_sys_t *p_sys = p_demux->p_sys;
902
903 /* *** fix order (to be sure...) *** */
904 qsort( p_sys->subtitles.p_array, p_sys->subtitles.i_count, sizeof( p_sys->subtitles.p_array[0] ), subtitle_cmp);
905 }
906
907 static int TextLoad( text_t *txt, stream_t *s )
908 {
909 size_t i_line_max;
910
911 /* init txt */
912 i_line_max = 500;
913 txt->i_line_count = 0;
914 txt->i_line = 0;
915 txt->line = calloc( i_line_max, sizeof( char * ) );
916 if( !txt->line )
917 return VLC_ENOMEM;
918
919 /* load the complete file */
920 for( ;; )
921 {
922 char *psz = vlc_stream_ReadLine( s );
923
924 if( psz == NULL )
925 break;
926
927 txt->line[txt->i_line_count] = psz;
928 if( txt->i_line_count + 1 >= i_line_max )
929 {
930 i_line_max += 100;
931 char **p_realloc = realloc( txt->line, i_line_max * sizeof( char * ) );
932 if( p_realloc == NULL )
933 return VLC_ENOMEM;
934 txt->line = p_realloc;
935 }
936 txt->i_line_count++;
937 }
938
939 if( txt->i_line_count == 0 )
940 {
941 free( txt->line );
942 return VLC_EGENERIC;
943 }
944
945 return VLC_SUCCESS;
946 }
947 static void TextUnload( text_t *txt )
948 {
949 if( txt->i_line_count )
950 {
951 for( size_t i = 0; i < txt->i_line_count; i++ )
952 free( txt->line[i] );
953 free( txt->line );
954 }
955 txt->i_line = 0;
956 txt->i_line_count = 0;
957 }
958
959 static char *TextGetLine( text_t *txt )
960 {
961 if( txt->i_line >= txt->i_line_count )
962 return( NULL );
963
964 return txt->line[txt->i_line++];
965 }
966 static void TextPreviousLine( text_t *txt )
967 {
968 if( txt->i_line > 0 )
969 txt->i_line--;
970 }
971
972 /*****************************************************************************
973 * Specific Subtitle function
974 *****************************************************************************/
975 /* ParseMicroDvd:
976 * Format:
977 * {n1}{n2}Line1|Line2|Line3....
978 * where n1 and n2 are the video frame number (n2 can be empty)
979 */
980 static int ParseMicroDvd( vlc_object_t *p_obj, subs_properties_t *p_props,
981 text_t *txt, subtitle_t *p_subtitle,
982 size_t i_idx )
983 {
984 VLC_UNUSED( i_idx );
985 char *psz_text;
986 int i_start;
987 int i_stop;
988 int i;
989
990 for( ;; )
991 {
992 const char *s = TextGetLine( txt );
993 if( !s )
994 return VLC_EGENERIC;
995
996 psz_text = malloc( strlen(s) + 1 );
997 if( !psz_text )
998 return VLC_ENOMEM;
999
1000 i_start = 0;
1001 i_stop = -1;
1002 if( sscanf( s, "{%d}{}%[^\r\n]", &i_start, psz_text ) == 2 ||
1003 sscanf( s, "{%d}{%d}%[^\r\n]", &i_start, &i_stop, psz_text ) == 3)
1004 {
1005 if( i_start != 1 || i_stop != 1 )
1006 break;
1007
1008 /* We found a possible setting of the framerate "{1}{1}23.976" */
1009 /* Check if it's usable, and if the sub-original-fps is not set */
1010 float f_fps = us_strtof( psz_text, NULL );
1011 if( f_fps > 0.f && var_GetFloat( p_obj, "sub-original-fps" ) <= 0.f )
1012 p_props->i_microsecperframe = llroundf((float)CLOCK_FREQ / f_fps);
1013 }
1014 free( psz_text );
1015 }
1016
1017 /* replace | by \n */
1018 for( i = 0; psz_text[i] != '\0'; i++ )
1019 {
1020 if( psz_text[i] == '|' )
1021 psz_text[i] = '\n';
1022 }
1023
1024 /* */
1025 p_subtitle->i_start = i_start * p_props->i_microsecperframe;
1026 p_subtitle->i_stop = i_stop >= 0 ? (i_stop * p_props->i_microsecperframe) : -1;
1027 p_subtitle->psz_text = psz_text;
1028 return VLC_SUCCESS;
1029 }
1030
1031 /* ParseSubRipSubViewer
1032 * Format SubRip
1033 * n
1034 * h1:m1:s1,d1 --> h2:m2:s2,d2
1035 * Line1
1036 * Line2
1037 * ....
1038 * [Empty line]
1039 * Format SubViewer v1/v2
1040 * h1:m1:s1.d1,h2:m2:s2.d2
1041 * Line1[br]Line2
1042 * Line3
1043 * ...
1044 * [empty line]
1045 * We ignore line number for SubRip
1046 */
1047 static int ParseSubRipSubViewer( vlc_object_t *p_obj, subs_properties_t *p_props,
1048 text_t *txt, subtitle_t *p_subtitle,
1049 int (* pf_parse_timing)(subtitle_t *, const char *),
1050 bool b_replace_br )
1051 {
1052 VLC_UNUSED(p_obj);
1053 VLC_UNUSED(p_props);
1054 char *psz_text;
1055
1056 for( ;; )
1057 {
1058 const char *s = TextGetLine( txt );
1059
1060 if( !s )
1061 return VLC_EGENERIC;
1062
1063 if( pf_parse_timing( p_subtitle, s) == VLC_SUCCESS &&
1064 p_subtitle->i_start < p_subtitle->i_stop )
1065 {
1066 break;
1067 }
1068 }
1069
1070 /* Now read text until an empty line */
1071 psz_text = strdup("");
1072 if( !psz_text )
1073 return VLC_ENOMEM;
1074
1075 for( ;; )
1076 {
1077 const char *s = TextGetLine( txt );
1078 size_t i_len;
1079 size_t i_old;
1080
1081 i_len = s ? strlen( s ) : 0;
1082 if( i_len <= 0 )
1083 {
1084 p_subtitle->psz_text = psz_text;
1085 return VLC_SUCCESS;
1086 }
1087
1088 i_old = strlen( psz_text );
1089 psz_text = realloc_or_free( psz_text, i_old + i_len + 1 + 1 );
1090 if( !psz_text )
1091 {
1092 return VLC_ENOMEM;
1093 }
1094 strcat( psz_text, s );
1095 strcat( psz_text, "\n" );
1096
1097 /* replace [br] by \n */
1098 if( b_replace_br )
1099 {
1100 char *p;
1101
1102 while( ( p = strstr( psz_text, "[br]" ) ) )
1103 {
1104 *p++ = '\n';
1105 memmove( p, &p[3], strlen(&p[3])+1 );
1106 }
1107 }
1108 }
1109 }
1110
1111 /* subtitle_ParseSubRipTimingValue
1112 * Parses SubRip timing value.
1113 */
1114 static int subtitle_ParseSubRipTimingValue(vlc_tick_t *timing_value,
1115 const char *s)
1116 {
1117 int h1, m1, s1, d1 = 0;
1118
1119 if ( sscanf( s, "%d:%d:%d,%d",
1120 &h1, &m1, &s1, &d1 ) == 4 ||
1121 sscanf( s, "%d:%d:%d.%d",
1122 &h1, &m1, &s1, &d1 ) == 4 ||
1123 sscanf( s, "%d:%d:%d",
1124 &h1, &m1, &s1) == 3 )
1125 {
1126 (*timing_value) = vlc_tick_from_sec( h1 * 3600 + m1 * 60 + s1) +
1127 VLC_TICK_FROM_MS( d1 );
1128
1129 return VLC_SUCCESS;
1130 }
1131
1132 return VLC_EGENERIC;
1133 }
1134
1135 /* subtitle_ParseSubRipTiming
1136 * Parses SubRip timing.
1137 */
1138 static int subtitle_ParseSubRipTiming( subtitle_t *p_subtitle,
1139 const char *s )
1140 {
1141 int i_result = VLC_EGENERIC;
1142 char *psz_start, *psz_stop;
1143 psz_start = malloc( strlen(s) + 1 );
1144 psz_stop = malloc( strlen(s) + 1 );
1145
1146 if( sscanf( s, "%s --> %s", psz_start, psz_stop) == 2 &&
1147 subtitle_ParseSubRipTimingValue( &p_subtitle->i_start, psz_start ) == VLC_SUCCESS &&
1148 subtitle_ParseSubRipTimingValue( &p_subtitle->i_stop, psz_stop ) == VLC_SUCCESS )
1149 {
1150 i_result = VLC_SUCCESS;
1151 }
1152
1153 free(psz_start);
1154 free(psz_stop);
1155
1156 return i_result;
1157 }
1158 /* ParseSubRip
1159 */
1160 static int ParseSubRip( vlc_object_t *p_obj, subs_properties_t *p_props,
1161 text_t *txt, subtitle_t *p_subtitle,
1162 size_t i_idx )
1163 {
1164 VLC_UNUSED( i_idx );
1165 return ParseSubRipSubViewer( p_obj, p_props, txt, p_subtitle,
1166 &subtitle_ParseSubRipTiming,
1167 false );
1168 }
1169
1170 /* subtitle_ParseSubViewerTiming
1171 * Parses SubViewer timing.
1172 */
1173 static int subtitle_ParseSubViewerTiming( subtitle_t *p_subtitle,
1174 const char *s )
1175 {
1176 int h1, m1, s1, d1, h2, m2, s2, d2;
1177
1178 if( sscanf( s, "%d:%d:%d.%d,%d:%d:%d.%d",
1179 &h1, &m1, &s1, &d1, &h2, &m2, &s2, &d2) == 8 )
1180 {
1181 p_subtitle->i_start = vlc_tick_from_sec( h1 * 3600 + m1 * 60 + s1) +
1182 VLC_TICK_FROM_MS( d1 );
1183
1184 p_subtitle->i_stop = vlc_tick_from_sec( h2 * 3600 + m2 * 60 + s2 ) +
1185 VLC_TICK_FROM_MS( d2 );
1186 return VLC_SUCCESS;
1187 }
1188 return VLC_EGENERIC;
1189 }
1190
1191 /* ParseSubViewer
1192 */
1193 static int ParseSubViewer( vlc_object_t *p_obj, subs_properties_t *p_props,
1194 text_t *txt, subtitle_t *p_subtitle,
1195 size_t i_idx )
1196 {
1197 VLC_UNUSED( i_idx );
1198
1199 return ParseSubRipSubViewer( p_obj, p_props, txt, p_subtitle,
1200 &subtitle_ParseSubViewerTiming,
1201 true );
1202 }
1203
1204 /* ParseSSA
1205 */
1206 static int ParseSSA( vlc_object_t *p_obj, subs_properties_t *p_props,
1207 text_t *txt, subtitle_t *p_subtitle,
1208 size_t i_idx )
1209 {
1210 VLC_UNUSED(p_obj);
1211 size_t header_len = 0;
1212
1213 for( ;; )
1214 {
1215 const char *s = TextGetLine( txt );
1216 int h1, m1, s1, c1, h2, m2, s2, c2;
1217 char *psz_text, *psz_temp;
1218 char temp[16];
1219
1220 if( !s )
1221 return VLC_EGENERIC;
1222
1223 /* We expect (SSA2-4):
1224 * Format: Marked, Start, End, Style, Name, MarginL, MarginR, MarginV, Effect, Text
1225 * Dialogue: Marked=0,0:02:40.65,0:02:41.79,Wolf main,Cher,0000,0000,0000,,Et les enregistrements de ses ondes delta ?
1226 *
1227 * SSA-1 is similar but only has 8 commas up untill the subtitle text. Probably the Effect field is no present, but not 100 % sure.
1228 */
1229
1230 /* For ASS:
1231 * Format: Layer, Start, End, Style, Name, MarginL, MarginR, MarginV, Effect, Text
1232 * Dialogue: Layer#,0:02:40.65,0:02:41.79,Wolf main,Cher,0000,0000,0000,,Et les enregistrements de ses ondes delta ?
1233 */
1234
1235 /* The output text is - at least, not removing numbers - 18 chars shorter than the input text. */
1236 psz_text = malloc( strlen(s) );
1237 if( !psz_text )
1238 return VLC_ENOMEM;
1239
1240 if( sscanf( s,
1241 "Dialogue: %15[^,],%d:%d:%d.%d,%d:%d:%d.%d,%[^\r\n]",
1242 temp,
1243 &h1, &m1, &s1, &c1,
1244 &h2, &m2, &s2, &c2,
1245 psz_text ) == 10 )
1246 {
1247 /* The dec expects: ReadOrder, Layer, Style, Name, MarginL, MarginR, MarginV, Effect, Text */
1248 /* (Layer comes from ASS specs ... it's empty for SSA.) */
1249 if( p_props->i_type == SUB_TYPE_SSA1 )
1250 {
1251 /* SSA1 has only 8 commas before the text starts, not 9 */
1252 memmove( &psz_text[1], psz_text, strlen(psz_text)+1 );
1253 psz_text[0] = ',';
1254 }
1255 else
1256 {
1257 int i_layer = ( p_props->i_type == SUB_TYPE_ASS ) ? atoi( temp ) : 0;
1258
1259 /* ReadOrder, Layer, %s(rest of fields) */
1260 if( asprintf( &psz_temp, "%zu,%d,%s", i_idx, i_layer, psz_text ) == -1 )
1261 {
1262 free( psz_text );
1263 return VLC_ENOMEM;
1264 }
1265
1266 free( psz_text );
1267 psz_text = psz_temp;
1268 }
1269
1270 p_subtitle->i_start = vlc_tick_from_sec( h1 * 3600 + m1 * 60 + s1 ) +
1271 VLC_TICK_FROM_MS( c1 * 10 );
1272 p_subtitle->i_stop = vlc_tick_from_sec( h2 * 3600 + m2 * 60 + s2 ) +
1273 VLC_TICK_FROM_MS( c2 * 10 );
1274 p_subtitle->psz_text = psz_text;
1275 return VLC_SUCCESS;
1276 }
1277 free( psz_text );
1278
1279 /* All the other stuff we add to the header field */
1280 if( header_len == 0 && p_props->psz_header )
1281 header_len = strlen( p_props->psz_header );
1282
1283 size_t s_len = strlen( s );
1284 p_props->psz_header = realloc_or_free( p_props->psz_header, header_len + s_len + 2 );
1285 if( !p_props->psz_header )
1286 return VLC_ENOMEM;
1287 snprintf( p_props->psz_header + header_len, s_len + 2, "%s\n", s );
1288 header_len += s_len + 1;
1289 }
1290 }
1291
1292 /* ParseVplayer
1293 * Format
1294 * h:m:s:Line1|Line2|Line3....
1295 * or
1296 * h:m:s Line1|Line2|Line3....
1297 */
1298 static int ParseVplayer( vlc_object_t *p_obj, subs_properties_t *p_props,
1299 text_t *txt, subtitle_t *p_subtitle,
1300 size_t i_idx )
1301 {
1302 VLC_UNUSED(p_obj);
1303 VLC_UNUSED(p_props);
1304 VLC_UNUSED( i_idx );
1305 char *psz_text;
1306
1307 for( ;; )
1308 {
1309 const char *s = TextGetLine( txt );
1310 int h1, m1, s1;
1311
1312 if( !s )
1313 return VLC_EGENERIC;
1314
1315 psz_text = malloc( strlen( s ) + 1 );
1316 if( !psz_text )
1317 return VLC_ENOMEM;
1318
1319 if( sscanf( s, "%d:%d:%d%*c%[^\r\n]",
1320 &h1, &m1, &s1, psz_text ) == 4 )
1321 {
1322 p_subtitle->i_start = vlc_tick_from_sec( h1 * 3600 + m1 * 60 + s1 );
1323 p_subtitle->i_stop = -1;
1324 break;
1325 }
1326 free( psz_text );
1327 }
1328
1329 /* replace | by \n */
1330 for( size_t i = 0; psz_text[i] != '\0'; i++ )
1331 {
1332 if( psz_text[i] == '|' )
1333 psz_text[i] = '\n';
1334 }
1335 p_subtitle->psz_text = psz_text;
1336 return VLC_SUCCESS;
1337 }
1338
1339 /* ParseSami
1340 */
1341 static const char *ParseSamiSearch( text_t *txt,
1342 const char *psz_start, const char *psz_str )
1343 {
1344 if( psz_start && strcasestr( psz_start, psz_str ) )
1345 {
1346 const char *s = strcasestr( psz_start, psz_str );
1347 return &s[strlen( psz_str )];
1348 }
1349
1350 for( ;; )
1351 {
1352 const char *p = TextGetLine( txt );
1353 if( !p )
1354 return NULL;
1355
1356 const char *s = strcasestr( p, psz_str );
1357 if( s != NULL )
1358 return &s[strlen( psz_str )];
1359 }
1360 }
1361 static int ParseSami( vlc_object_t *p_obj, subs_properties_t *p_props,
1362 text_t *txt, subtitle_t *p_subtitle, size_t i_idx )
1363 {
1364 VLC_UNUSED(p_obj);
1365 VLC_UNUSED(p_props);
1366 VLC_UNUSED( i_idx );
1367 const char *s;
1368 int64_t i_start;
1369
1370 unsigned int i_text;
1371 char text[8192]; /* Arbitrary but should be long enough */
1372
1373 /* search "Start=" */
1374 s = ParseSamiSearch( txt, p_props->sami.psz_start, "Start=" );
1375 p_props->sami.psz_start = NULL;
1376 if( !s )
1377 return VLC_EGENERIC;
1378
1379 /* get start value */
1380 char *psz_end;
1381 i_start = strtol( s, &psz_end, 0 );
1382 s = psz_end;
1383
1384 /* search <P */
1385 if( !( s = ParseSamiSearch( txt, s, "<P" ) ) )
1386 return VLC_EGENERIC;
1387
1388 /* search > */
1389 if( !( s = ParseSamiSearch( txt, s, ">" ) ) )
1390 return VLC_EGENERIC;
1391
1392 i_text = 0;
1393 text[0] = '\0';
1394 /* now get all txt until a "Start=" line */
1395 for( ;; )
1396 {
1397 char c = '\0';
1398 /* Search non empty line */
1399 while( s && *s == '\0' )
1400 s = TextGetLine( txt );
1401 if( !s )
1402 break;
1403
1404 if( *s == '<' )
1405 {
1406 if( !strncasecmp( s, "<br", 3 ) )
1407 {
1408 c = '\n';
1409 }
1410 else if( strcasestr( s, "Start=" ) )
1411 {
1412 p_props->sami.psz_start = s;
1413 break;
1414 }
1415 s = ParseSamiSearch( txt, s, ">" );
1416 }
1417 else if( !strncmp( s, "&nbsp;", 6 ) )
1418 {
1419 c = ' ';
1420 s += 6;
1421 }
1422 else if( *s == '\t' )
1423 {
1424 c = ' ';
1425 s++;
1426 }
1427 else
1428 {
1429 c = *s;
1430 s++;
1431 }
1432 if( c != '\0' && i_text+1 < sizeof(text) )
1433 {
1434 text[i_text++] = c;
1435 text[i_text] = '\0';
1436 }
1437 }
1438
1439 p_subtitle->i_start = VLC_TICK_FROM_MS(i_start);
1440 p_subtitle->i_stop = -1;
1441 p_subtitle->psz_text = strdup( text );
1442
1443 return VLC_SUCCESS;
1444 }
1445
1446 /* ParseDVDSubtitle
1447 * Format
1448 * {T h1:m1:s1:c1
1449 * Line1
1450 * Line2
1451 * ...
1452 * }
1453 * TODO it can have a header
1454 * { HEAD
1455 * ...
1456 * CODEPAGE=...
1457 * FORMAT=...
1458 * LANG=English
1459 * }
1460 * LANG support would be cool
1461 * CODEPAGE is probably mandatory FIXME
1462 */
1463 static int ParseDVDSubtitle(vlc_object_t *p_obj, subs_properties_t *p_props,
1464 text_t *txt, subtitle_t *p_subtitle, size_t i_idx )
1465 {
1466 VLC_UNUSED(p_obj);
1467 VLC_UNUSED(p_props);
1468 VLC_UNUSED( i_idx );
1469 char *psz_text;
1470
1471 for( ;; )
1472 {
1473 const char *s = TextGetLine( txt );
1474 int h1, m1, s1, c1;
1475
1476 if( !s )
1477 return VLC_EGENERIC;
1478
1479 if( sscanf( s,
1480 "{T %d:%d:%d:%d",
1481 &h1, &m1, &s1, &c1 ) == 4 )
1482 {
1483 p_subtitle->i_start = vlc_tick_from_sec( h1 * 3600 + m1 * 60 + s1 ) +
1484 VLC_TICK_FROM_MS( c1 * 10 );
1485 p_subtitle->i_stop = -1;
1486 break;
1487 }
1488 }
1489
1490 /* Now read text until a line containing "}" */
1491 psz_text = strdup("");
1492 if( !psz_text )
1493 return VLC_ENOMEM;
1494 for( ;; )
1495 {
1496 const char *s = TextGetLine( txt );
1497 int i_len;
1498 int i_old;
1499
1500 if( !s )
1501 {
1502 free( psz_text );
1503 return VLC_EGENERIC;
1504 }
1505
1506 i_len = strlen( s );
1507 if( i_len == 1 && s[0] == '}')
1508 {
1509 p_subtitle->psz_text = psz_text;
1510 return VLC_SUCCESS;
1511 }
1512
1513 i_old = strlen( psz_text );
1514 psz_text = realloc_or_free( psz_text, i_old + i_len + 1 + 1 );
1515 if( !psz_text )
1516 return VLC_ENOMEM;
1517 strcat( psz_text, s );
1518 strcat( psz_text, "\n" );
1519 }
1520 }
1521
1522 /* ParseMPL2
1523 * Format
1524 * [n1][n2]Line1|Line2|Line3...
1525 * where n1 and n2 are the video frame number (n2 can be empty)
1526 */
1527 static int ParseMPL2(vlc_object_t *p_obj, subs_properties_t *p_props,
1528 text_t *txt, subtitle_t *p_subtitle, size_t i_idx )
1529 {
1530 VLC_UNUSED(p_obj);
1531 VLC_UNUSED(p_props);
1532 VLC_UNUSED( i_idx );
1533 char *psz_text;
1534 int i;
1535
1536 for( ;; )
1537 {
1538 const char *s = TextGetLine( txt );
1539 int i_start;
1540 int i_stop;
1541
1542 if( !s )
1543 return VLC_EGENERIC;
1544
1545 psz_text = malloc( strlen(s) + 1 );
1546 if( !psz_text )
1547 return VLC_ENOMEM;
1548
1549 i_start = 0;
1550 i_stop = -1;
1551 if( sscanf( s, "[%d][] %[^\r\n]", &i_start, psz_text ) == 2 ||
1552 sscanf( s, "[%d][%d] %[^\r\n]", &i_start, &i_stop, psz_text ) == 3)
1553 {
1554 p_subtitle->i_start = VLC_TICK_FROM_MS(i_start * 100);
1555 p_subtitle->i_stop = i_stop >= 0 ? VLC_TICK_FROM_MS(i_stop * 100) : -1;
1556 break;
1557 }
1558 free( psz_text );
1559 }
1560
1561 for( i = 0; psz_text[i] != '\0'; )
1562 {
1563 /* replace | by \n */
1564 if( psz_text[i] == '|' )
1565 psz_text[i] = '\n';
1566
1567 /* Remove italic */
1568 if( psz_text[i] == '/' && ( i == 0 || psz_text[i-1] == '\n' ) )
1569 memmove( &psz_text[i], &psz_text[i+1], strlen(&psz_text[i+1])+1 );
1570 else
1571 i++;
1572 }
1573 p_subtitle->psz_text = psz_text;
1574 return VLC_SUCCESS;
1575 }
1576
1577 static int ParseAQT(vlc_object_t *p_obj, subs_properties_t *p_props, text_t *txt, subtitle_t *p_subtitle, size_t i_idx )
1578 {
1579 VLC_UNUSED(p_obj);
1580 VLC_UNUSED(p_props);
1581 VLC_UNUSED( i_idx );
1582
1583 char *psz_text = strdup( "" );
1584 int i_old = 0;
1585 int i_firstline = 1;
1586
1587 for( ;; )
1588 {
1589 int t; /* Time */
1590
1591 const char *s = TextGetLine( txt );
1592
1593 if( !s )
1594 {
1595 free( psz_text );
1596 return VLC_EGENERIC;
1597 }
1598
1599 /* Data Lines */
1600 if( sscanf (s, "-->> %d", &t) == 1)
1601 {
1602 /* Starting of a subtitle */
1603 if( i_firstline )
1604 {
1605 p_subtitle->i_start = t * p_props->i_microsecperframe;
1606 i_firstline = 0;
1607 }
1608 /* We have been too far: end of the subtitle, begin of next */
1609 else
1610 {
1611 p_subtitle->i_stop = t * p_props->i_microsecperframe;
1612 break;
1613 }
1614 }
1615 /* Text Lines */
1616 else
1617 {
1618 i_old = strlen( psz_text ) + 1;
1619 psz_text = realloc_or_free( psz_text, i_old + strlen( s ) + 1 );
1620 if( !psz_text )
1621 return VLC_ENOMEM;
1622 strcat( psz_text, s );
1623 strcat( psz_text, "\n" );
1624 if( txt->i_line == txt->i_line_count )
1625 break;
1626 }
1627 }
1628 p_subtitle->psz_text = psz_text;
1629 return VLC_SUCCESS;
1630 }
1631
1632 static int ParsePJS(vlc_object_t *p_obj, subs_properties_t *p_props,
1633 text_t *txt, subtitle_t *p_subtitle, size_t i_idx )
1634 {
1635 VLC_UNUSED(p_obj);
1636 VLC_UNUSED(p_props);
1637 VLC_UNUSED( i_idx );
1638
1639 char *psz_text;
1640 int i;
1641
1642 for( ;; )
1643 {
1644 const char *s = TextGetLine( txt );
1645 int t1, t2;
1646
1647 if( !s )
1648 return VLC_EGENERIC;
1649
1650 psz_text = malloc( strlen(s) + 1 );
1651 if( !psz_text )
1652 return VLC_ENOMEM;
1653
1654 /* Data Lines */
1655 if( sscanf (s, "%d,%d,\"%[^\n\r]", &t1, &t2, psz_text ) == 3 )
1656 {
1657 /* 1/10th of second ? Frame based ? FIXME */
1658 p_subtitle->i_start = 10 * t1;
1659 p_subtitle->i_stop = 10 * t2;
1660 /* Remove latest " */
1661 psz_text[ strlen(psz_text) - 1 ] = '\0';
1662
1663 break;
1664 }
1665 free( psz_text );
1666 }
1667
1668 /* replace | by \n */
1669 for( i = 0; psz_text[i] != '\0'; i++ )
1670 {
1671 if( psz_text[i] == '|' )
1672 psz_text[i] = '\n';
1673 }
1674
1675 p_subtitle->psz_text = psz_text;
1676 msg_Dbg( p_obj, "%s", psz_text );
1677 return VLC_SUCCESS;
1678 }
1679
1680 static int ParseMPSub( vlc_object_t *p_obj, subs_properties_t *p_props,
1681 text_t *txt, subtitle_t *p_subtitle, size_t i_idx )
1682 {
1683 VLC_UNUSED( i_idx );
1684
1685 char *psz_text = strdup( "" );
1686
1687 if( !p_props->mpsub.b_inited )
1688 {
1689 p_props->mpsub.f_total = 0.0;
1690 p_props->mpsub.i_factor = 0;
1691
1692 p_props->mpsub.b_inited = true;
1693 }
1694
1695 for( ;; )
1696 {
1697 char p_dummy;
1698 char *psz_temp;
1699
1700 const char *s = TextGetLine( txt );
1701 if( !s )
1702 {
1703 free( psz_text );
1704 return VLC_EGENERIC;
1705 }
1706
1707 if( strstr( s, "FORMAT" ) )
1708 {
1709 if( sscanf (s, "FORMAT=TIM%c", &p_dummy ) == 1 && p_dummy == 'E')
1710 {
1711 p_props->mpsub.i_factor = 100;
1712 break;
1713 }
1714
1715 psz_temp = malloc( strlen(s) );
1716 if( !psz_temp )
1717 {
1718 free( psz_text );
1719 return VLC_ENOMEM;
1720 }
1721
1722 if( sscanf( s, "FORMAT=%[^\r\n]", psz_temp ) )
1723 {
1724 float f_fps = us_strtof( psz_temp, NULL );
1725
1726 if( f_fps > 0.f && var_GetFloat( p_obj, "sub-original-fps" ) <= 0.f )
1727 var_SetFloat( p_obj, "sub-original-fps", f_fps );
1728
1729 p_props->mpsub.i_factor = 1;
1730 free( psz_temp );
1731 break;
1732 }
1733 free( psz_temp );
1734 }
1735
1736 /* Data Lines */
1737 float f1 = us_strtof( s, &psz_temp );
1738 if( *psz_temp )
1739 {
1740 float f2 = us_strtof( psz_temp, NULL );
1741 p_props->mpsub.f_total += f1 * p_props->mpsub.i_factor;
1742 p_subtitle->i_start = llroundf(10000.f * p_props->mpsub.f_total);
1743 p_props->mpsub.f_total += f2 * p_props->mpsub.i_factor;
1744 p_subtitle->i_stop = llroundf(10000.f * p_props->mpsub.f_total);
1745 break;
1746 }
1747 }
1748
1749 for( ;; )
1750 {
1751 const char *s = TextGetLine( txt );
1752
1753 if( !s )
1754 {
1755 free( psz_text );
1756 return VLC_EGENERIC;
1757 }
1758
1759 size_t i_len = strlen( s );
1760 if( i_len == 0 )
1761 break;
1762
1763 size_t i_old = strlen( psz_text );
1764
1765 psz_text = realloc_or_free( psz_text, i_old + i_len + 1 + 1 );
1766 if( !psz_text )
1767 return VLC_ENOMEM;
1768
1769 strcat( psz_text, s );
1770 strcat( psz_text, "\n" );
1771 }
1772
1773 p_subtitle->psz_text = psz_text;
1774 return VLC_SUCCESS;
1775 }
1776
1777 static int ParseJSS( vlc_object_t *p_obj, subs_properties_t *p_props,
1778 text_t *txt, subtitle_t *p_subtitle, size_t i_idx )
1779 {
1780 VLC_UNUSED( i_idx );
1781 char *psz_text, *psz_orig;
1782 char *psz_text2, *psz_orig2;
1783
1784 if( !p_props->jss.b_inited )
1785 {
1786 p_props->jss.i_comment = 0;
1787 p_props->jss.i_time_resolution = 30;
1788 p_props->jss.i_time_shift = 0;
1789
1790 p_props->jss.b_inited = true;
1791 }
1792
1793 /* Parse the main lines */
1794 for( ;; )
1795 {
1796 const char *s = TextGetLine( txt );
1797 if( !s )
1798 return VLC_EGENERIC;
1799
1800 size_t line_length = strlen( s );
1801 psz_orig = malloc( line_length + 1 );
1802 if( !psz_orig )
1803 return VLC_ENOMEM;
1804 psz_text = psz_orig;
1805
1806 /* Complete time lines */
1807 int h1, h2, m1, m2, s1, s2, f1, f2;
1808 if( sscanf( s, "%d:%d:%d.%d %d:%d:%d.%d %[^\n\r]",
1809 &h1, &m1, &s1, &f1, &h2, &m2, &s2, &f2, psz_text ) == 9 )
1810 {
1811 p_subtitle->i_start = vlc_tick_from_sec( ( h1 *3600 + m1 * 60 + s1 ) +
1812 (int64_t)( ( f1 + p_props->jss.i_time_shift ) / p_props->jss.i_time_resolution ) );
1813 p_subtitle->i_stop = vlc_tick_from_sec( ( h2 *3600 + m2 * 60 + s2 ) +
1814 (int64_t)( ( f2 + p_props->jss.i_time_shift ) / p_props->jss.i_time_resolution ) );
1815 break;
1816 }
1817 /* Short time lines */
1818 else if( sscanf( s, "@%d @%d %[^\n\r]", &f1, &f2, psz_text ) == 3 )
1819 {
1820 p_subtitle->i_start =
1821 vlc_tick_from_sec( (f1 + p_props->jss.i_time_shift ) / p_props->jss.i_time_resolution );
1822 p_subtitle->i_stop =
1823 vlc_tick_from_sec( (f2 + p_props->jss.i_time_shift ) / p_props->jss.i_time_resolution );
1824 break;
1825 }
1826 /* General Directive lines */
1827 /* Only TIME and SHIFT are supported so far */
1828 else if( s[0] == '#' )
1829 {
1830 int h = 0, m =0, sec = 1, f = 1;
1831 unsigned shift = 1;
1832 int inv = 1;
1833
1834 strcpy( psz_text, s );
1835
1836 switch( toupper( (unsigned char)psz_text[1] ) )
1837 {
1838 case 'S':
1839 shift = isalpha( (unsigned char)psz_text[2] ) ? 6 : 2 ;
1840 if ( shift > line_length )
1841 break;
1842
1843 if( sscanf( &psz_text[shift], "%d", &h ) )
1844 {
1845 /* Negative shifting */
1846 if( h < 0 )
1847 {
1848 h *= -1;
1849 inv = -1;
1850 }
1851
1852 if( sscanf( &psz_text[shift], "%*d:%d", &m ) )
1853 {
1854 if( sscanf( &psz_text[shift], "%*d:%*d:%d", &sec ) )
1855 {
1856 sscanf( &psz_text[shift], "%*d:%*d:%*d.%d", &f );
1857 }
1858 else
1859 {
1860 h = 0;
1861 sscanf( &psz_text[shift], "%d:%d.%d",
1862 &m, &sec, &f );
1863 m *= inv;
1864 }
1865 }
1866 else
1867 {
1868 h = m = 0;
1869 sscanf( &psz_text[shift], "%d.%d", &sec, &f);
1870 sec *= inv;
1871 }
1872 p_props->jss.i_time_shift = ( ( h * 3600 + m * 60 + sec )
1873 * p_props->jss.i_time_resolution + f ) * inv;
1874 }
1875 break;
1876
1877 case 'T':
1878 shift = isalpha( (unsigned char)psz_text[2] ) ? 8 : 2 ;
1879 if ( shift > line_length )
1880 break;
1881
1882 sscanf( &psz_text[shift], "%d", &p_props->jss.i_time_resolution );
1883 if( !p_props->jss.i_time_resolution )
1884 p_props->jss.i_time_resolution = 30;
1885 break;
1886 }
1887 free( psz_orig );
1888 continue;
1889 }
1890 else
1891 /* Unkown type line, probably a comment */
1892 {
1893 free( psz_orig );
1894 continue;
1895 }
1896 }
1897
1898 while( psz_text[ strlen( psz_text ) - 1 ] == '\\' )
1899 {
1900 const char *s2 = TextGetLine( txt );
1901
1902 if( !s2 )
1903 {
1904 free( psz_orig );
1905 return VLC_EGENERIC;
1906 }
1907
1908 size_t i_len = strlen( s2 );
1909 if( i_len == 0 )
1910 break;
1911
1912 size_t i_old = strlen( psz_text );
1913
1914 psz_text = realloc_or_free( psz_text, i_old + i_len + 1 );
1915 if( !psz_text )
1916 return VLC_ENOMEM;
1917
1918 psz_orig = psz_text;
1919 strcat( psz_text, s2 );
1920 }
1921
1922 /* Skip the blanks */
1923 while( *psz_text == ' ' || *psz_text == '\t' ) psz_text++;
1924
1925 /* Parse the directives */
1926 if( isalpha( (unsigned char)*psz_text ) || *psz_text == '[' )
1927 {
1928 while( *psz_text && *psz_text != ' ' )
1929 ++psz_text;
1930
1931 /* Directives are NOT parsed yet */
1932 /* This has probably a better place in a decoder ? */
1933 /* directive = malloc( strlen( psz_text ) + 1 );
1934 if( sscanf( psz_text, "%s %[^\n\r]", directive, psz_text2 ) == 2 )*/
1935 }
1936
1937 /* Skip the blanks after directives */
1938 while( *psz_text == ' ' || *psz_text == '\t' ) psz_text++;
1939
1940 /* Clean all the lines from inline comments and other stuffs */
1941 psz_orig2 = calloc( strlen( psz_text) + 1, 1 );
1942 psz_text2 = psz_orig2;
1943
1944 for( ; *psz_text != '\0' && *psz_text != '\n' && *psz_text != '\r'; )
1945 {
1946 switch( *psz_text )
1947 {
1948 case '{':
1949 p_props->jss.i_comment++;
1950 break;
1951 case '}':
1952 if( p_props->jss.i_comment )
1953 {
1954 p_props->jss.i_comment = 0;
1955 if( (*(psz_text + 1 ) ) == ' ' ) psz_text++;
1956 }
1957 break;
1958 case '~':
1959 if( !p_props->jss.i_comment )
1960 {
1961 *psz_text2 = ' ';
1962 psz_text2++;
1963 }
1964 break;
1965 case ' ':
1966 case '\t':
1967 if( (*(psz_text + 1 ) ) == ' ' || (*(psz_text + 1 ) ) == '\t' )
1968 break;
1969 if( !p_props->jss.i_comment )
1970 {
1971 *psz_text2 = ' ';
1972 psz_text2++;
1973 }
1974 break;
1975 case '\\':
1976 if( (*(psz_text + 1 ) ) == 'n' )
1977 {
1978 *psz_text2 = '\n';
1979 psz_text++;
1980 psz_text2++;
1981 break;
1982 }
1983 if( ( toupper((unsigned char)*(psz_text + 1 ) ) == 'C' ) ||
1984 ( toupper((unsigned char)*(psz_text + 1 ) ) == 'F' ) )
1985 {
1986 psz_text++;
1987 break;
1988 }
1989 if( (*(psz_text + 1 ) ) == 'B' || (*(psz_text + 1 ) ) == 'b' ||
1990 (*(psz_text + 1 ) ) == 'I' || (*(psz_text + 1 ) ) == 'i' ||
1991 (*(psz_text + 1 ) ) == 'U' || (*(psz_text + 1 ) ) == 'u' ||
1992 (*(psz_text + 1 ) ) == 'D' || (*(psz_text + 1 ) ) == 'N' )
1993 {
1994 psz_text++;
1995 break;
1996 }
1997 if( (*(psz_text + 1 ) ) == '~' || (*(psz_text + 1 ) ) == '{' ||
1998 (*(psz_text + 1 ) ) == '\\' )
1999 psz_text++;
2000 else if( ( *(psz_text + 1 ) == '\r' || *(psz_text + 1 ) == '\n' ) &&
2001 *(psz_text + 1 ) != '\0' )
2002 {
2003 psz_text++;
2004 }
2005 break;
2006 default:
2007 if( !p_props->jss.i_comment )
2008 {
2009 *psz_text2 = *psz_text;
2010 psz_text2++;
2011 }
2012 }
2013 psz_text++;
2014 }
2015
2016 p_subtitle->psz_text = psz_orig2;
2017 msg_Dbg( p_obj, "%s", p_subtitle->psz_text );
2018 free( psz_orig );
2019 return VLC_SUCCESS;
2020 }
2021
2022 static int ParsePSB( vlc_object_t *p_obj, subs_properties_t *p_props,
2023 text_t *txt, subtitle_t *p_subtitle, size_t i_idx )
2024 {
2025 VLC_UNUSED(p_obj);
2026 VLC_UNUSED(p_props);
2027 VLC_UNUSED( i_idx );
2028
2029 char *psz_text;
2030 int i;
2031
2032 for( ;; )
2033 {
2034 int h1, m1, s1;
2035 int h2, m2, s2;
2036 const char *s = TextGetLine( txt );
2037
2038 if( !s )
2039 return VLC_EGENERIC;
2040
2041 psz_text = malloc( strlen( s ) + 1 );
2042 if( !psz_text )
2043 return VLC_ENOMEM;
2044
2045 if( sscanf( s, "{%d:%d:%d}{%d:%d:%d}%[^\r\n]",
2046 &h1, &m1, &s1, &h2, &m2, &s2, psz_text ) == 7 )
2047 {
2048 p_subtitle->i_start = vlc_tick_from_sec( h1 * 3600 + m1 * 60 + s1 );
2049 p_subtitle->i_stop = vlc_tick_from_sec( h2 * 3600 + m2 * 60 + s2 );
2050 break;
2051 }
2052 free( psz_text );
2053 }
2054
2055 /* replace | by \n */
2056 for( i = 0; psz_text[i] != '\0'; i++ )
2057 {
2058 if( psz_text[i] == '|' )
2059 psz_text[i] = '\n';
2060 }
2061 p_subtitle->psz_text = psz_text;
2062 return VLC_SUCCESS;
2063 }
2064
2065 static int64_t ParseRealTime( char *psz, int *h, int *m, int *s, int *f )
2066 {
2067 if( *psz == '\0' ) return 0;
2068 if( sscanf( psz, "%d:%d:%d.%d", h, m, s, f ) == 4 ||
2069 sscanf( psz, "%d:%d.%d", m, s, f ) == 3 ||
2070 sscanf( psz, "%d.%d", s, f ) == 2 ||
2071 sscanf( psz, "%d:%d", m, s ) == 2 ||
2072 sscanf( psz, "%d", s ) == 1 )
2073 {
2074 return vlc_tick_from_sec((( *h * 60 + *m ) * 60 ) + *s )
2075 + VLC_TICK_FROM_MS(*f * 10);
2076 }
2077 else return VLC_EGENERIC;
2078 }
2079
2080 static int ParseRealText( vlc_object_t *p_obj, subs_properties_t *p_props,
2081 text_t *txt, subtitle_t *p_subtitle, size_t i_idx )
2082 {
2083 VLC_UNUSED(p_obj);
2084 VLC_UNUSED(p_props);
2085 VLC_UNUSED( i_idx );
2086 char *psz_text = NULL;
2087
2088 for( ;; )
2089 {
2090 int h1 = 0, m1 = 0, s1 = 0, f1 = 0;
2091 int h2 = 0, m2 = 0, s2 = 0, f2 = 0;
2092 const char *s = TextGetLine( txt );
2093 free( psz_text );
2094
2095 if( !s )
2096 return VLC_EGENERIC;
2097
2098 psz_text = malloc( strlen( s ) + 1 );
2099 if( !psz_text )
2100 return VLC_ENOMEM;
2101
2102 /* Find the good begining. This removes extra spaces at the beginning
2103 of the line.*/
2104 char *psz_temp = strcasestr( s, "<time");
2105 if( psz_temp != NULL )
2106 {
2107 char psz_end[12], psz_begin[12];
2108 /* Line has begin and end */
2109 if( ( sscanf( psz_temp,
2110 "<%*[t|T]ime %*[b|B]egin=\"%11[^\"]\" %*[e|E]nd=\"%11[^\"]%*[^>]%[^\n\r]",
2111 psz_begin, psz_end, psz_text) != 3 ) &&
2112 /* Line has begin and no end */
2113 ( sscanf( psz_temp,
2114 "<%*[t|T]ime %*[b|B]egin=\"%11[^\"]\"%*[^>]%[^\n\r]",
2115 psz_begin, psz_text ) != 2) )
2116 /* Line is not recognized */
2117 {
2118 continue;
2119 }
2120
2121 /* Get the times */
2122 int64_t i_time = ParseRealTime( psz_begin, &h1, &m1, &s1, &f1 );
2123 p_subtitle->i_start = i_time >= 0 ? i_time : 0;
2124
2125 i_time = ParseRealTime( psz_end, &h2, &m2, &s2, &f2 );
2126 p_subtitle->i_stop = i_time >= 0 ? i_time : -1;
2127 break;
2128 }
2129 }
2130
2131 /* Get the following Lines */
2132 for( ;; )
2133 {
2134 const char *s = TextGetLine( txt );
2135
2136 if( !s )
2137 {
2138 free( psz_text );
2139 return VLC_EGENERIC;
2140 }
2141
2142 size_t i_len = strlen( s );
2143 if( i_len == 0 ) break;
2144
2145 if( strcasestr( s, "<time" ) ||
2146 strcasestr( s, "<clear/") )
2147 {
2148 TextPreviousLine( txt );
2149 break;
2150 }
2151
2152 size_t i_old = strlen( psz_text );
2153
2154 psz_text = realloc_or_free( psz_text, i_old + i_len + 1 + 1 );
2155 if( !psz_text )
2156 return VLC_ENOMEM;
2157
2158 strcat( psz_text, s );
2159 strcat( psz_text, "\n" );
2160 }
2161
2162 /* Remove the starting ">" that remained after the sscanf */
2163 memmove( &psz_text[0], &psz_text[1], strlen( psz_text ) );
2164
2165 p_subtitle->psz_text = psz_text;
2166
2167 return VLC_SUCCESS;
2168 }
2169
2170 static int ParseDKS( vlc_object_t *p_obj, subs_properties_t *p_props,
2171 text_t *txt, subtitle_t *p_subtitle, size_t i_idx )
2172 {
2173 VLC_UNUSED(p_obj);
2174 VLC_UNUSED(p_props);
2175 VLC_UNUSED( i_idx );
2176
2177 char *psz_text;
2178
2179 for( ;; )
2180 {
2181 int h1, m1, s1;
2182 int h2, m2, s2;
2183 char *s = TextGetLine( txt );
2184
2185 if( !s )
2186 return VLC_EGENERIC;
2187
2188 psz_text = malloc( strlen( s ) + 1 );
2189 if( !psz_text )
2190 return VLC_ENOMEM;
2191
2192 if( sscanf( s, "[%d:%d:%d]%[^\r\n]",
2193 &h1, &m1, &s1, psz_text ) == 4 )
2194 {
2195 p_subtitle->i_start = vlc_tick_from_sec( h1 * 3600 + m1 * 60 + s1 );
2196
2197 s = TextGetLine( txt );
2198 if( !s )
2199 {
2200 free( psz_text );
2201 return VLC_EGENERIC;
2202 }
2203
2204 if( sscanf( s, "[%d:%d:%d]", &h2, &m2, &s2 ) == 3 )
2205 p_subtitle->i_stop = vlc_tick_from_sec(h2 * 3600 + m2 * 60 + s2 );
2206 else
2207 p_subtitle->i_stop = -1;
2208 break;
2209 }
2210 free( psz_text );
2211 }
2212
2213 /* replace [br] by \n */
2214 char *p;
2215 while( ( p = strstr( psz_text, "[br]" ) ) )
2216 {
2217 *p++ = '\n';
2218 memmove( p, &p[3], strlen(&p[3])+1 );
2219 }
2220
2221 p_subtitle->psz_text = psz_text;
2222 return VLC_SUCCESS;
2223 }
2224
2225 static int ParseSubViewer1( vlc_object_t *p_obj, subs_properties_t *p_props,
2226 text_t *txt, subtitle_t *p_subtitle, size_t i_idx )
2227 {
2228 VLC_UNUSED(p_obj);
2229 VLC_UNUSED(p_props);
2230 VLC_UNUSED( i_idx );
2231 char *psz_text;
2232
2233 for( ;; )
2234 {
2235 int h1, m1, s1;
2236 int h2, m2, s2;
2237 char *s = TextGetLine( txt );
2238
2239 if( !s )
2240 return VLC_EGENERIC;
2241
2242 if( sscanf( s, "[%d:%d:%d]", &h1, &m1, &s1 ) == 3 )
2243 {
2244 p_subtitle->i_start = vlc_tick_from_sec( h1 * 3600 + m1 * 60 + s1 );
2245
2246 s = TextGetLine( txt );
2247 if( !s )
2248 return VLC_EGENERIC;
2249
2250 psz_text = strdup( s );
2251 if( !psz_text )
2252 return VLC_ENOMEM;
2253
2254 s = TextGetLine( txt );
2255 if( !s )
2256 {
2257 free( psz_text );
2258 return VLC_EGENERIC;
2259 }
2260
2261 if( sscanf( s, "[%d:%d:%d]", &h2, &m2, &s2 ) == 3 )
2262 p_subtitle->i_stop = vlc_tick_from_sec( h2 * 3600 + m2 * 60 + s2 );
2263 else
2264 p_subtitle->i_stop = -1;
2265
2266 break;
2267 }
2268 }
2269
2270 p_subtitle->psz_text = psz_text;
2271
2272 return VLC_SUCCESS;
2273 }
2274
2275 static int ParseCommonSBV( vlc_object_t *p_obj, subs_properties_t *p_props,
2276 text_t *txt, subtitle_t *p_subtitle, size_t i_idx )
2277 {
2278 VLC_UNUSED(p_obj);
2279 VLC_UNUSED( i_idx );
2280 VLC_UNUSED( p_props );
2281 char *psz_text;
2282
2283 for( ;; )
2284 {
2285 const char *s = TextGetLine( txt );
2286 int h1 = 0, m1 = 0, s1 = 0, d1 = 0;
2287 int h2 = 0, m2 = 0, s2 = 0, d2 = 0;
2288
2289 if( !s )
2290 return VLC_EGENERIC;
2291
2292 if( sscanf( s,"%d:%d:%d.%d,%d:%d:%d.%d",
2293 &h1, &m1, &s1, &d1,
2294 &h2, &m2, &s2, &d2 ) == 8 )
2295 {
2296 p_subtitle->i_start = vlc_tick_from_sec( h1 * 3600 + m1 * 60 + s1 ) +
2297 VLC_TICK_FROM_MS( d1 );
2298
2299 p_subtitle->i_stop = vlc_tick_from_sec( h2 * 3600 + m2 * 60 + s2 ) +
2300 VLC_TICK_FROM_MS( d2 );
2301 if( p_subtitle->i_start < p_subtitle->i_stop )
2302 break;
2303 }
2304 }
2305
2306 /* Now read text until an empty line */
2307 psz_text = strdup("");
2308 if( !psz_text )
2309 return VLC_ENOMEM;
2310
2311 for( ;; )
2312 {
2313 const char *s = TextGetLine( txt );
2314 size_t i_len;
2315 size_t i_old;
2316
2317 i_len = s ? strlen( s ) : 0;
2318 if( i_len <= 0 )
2319 {
2320 p_subtitle->psz_text = psz_text;
2321 return VLC_SUCCESS;
2322 }
2323
2324 i_old = strlen( psz_text );
2325 psz_text = realloc_or_free( psz_text, i_old + i_len + 1 + 1 );
2326 if( !psz_text )
2327 return VLC_ENOMEM;
2328
2329 strcat( psz_text, s );
2330 strcat( psz_text, "\n" );
2331 }
2332 }
2333
2334 static int ParseSCC( vlc_object_t *p_obj, subs_properties_t *p_props,
2335 text_t *txt, subtitle_t *p_subtitle, size_t i_idx )
2336 {
2337 VLC_UNUSED(p_obj);
2338 VLC_UNUSED( i_idx );
2339 VLC_UNUSED( p_props );
2340
2341 static const struct rates
2342 {
2343 unsigned val;
2344 vlc_rational_t rate;
2345 bool b_drop_allowed;
2346 } framerates[] = {
2347 { 2398, { 24000, 1001 }, false },
2348 { 2400, { 24, 1 }, false },
2349 { 2500, { 25, 1 }, false },
2350 { 2997, { 30000, 1001 }, true }, /* encoding rate */
2351 { 3000, { 30, 1 }, false },
2352 { 5000, { 50, 1 }, false },
2353 { 5994, { 60000, 1001 }, true },
2354 { 6000, { 60, 1 }, false },
2355 };
2356 const struct rates *p_rate = &framerates[3];
2357 float f_fps = var_GetFloat( p_obj, "sub-original-fps" );
2358 if( f_fps > 1.0 )
2359 {
2360 for( size_t i=0; i<ARRAY_SIZE(framerates); i++ )
2361 {
2362 if( (unsigned)(f_fps * 100) == framerates[i].val )
2363 {
2364 p_rate = &framerates[i];
2365 break;
2366 }
2367 }
2368 }
2369
2370 for( ;; )
2371 {
2372 const char *psz_line = TextGetLine( txt );
2373 if( !psz_line )
2374 return VLC_EGENERIC;
2375
2376 unsigned h, m, s, f;
2377 char c;
2378 if( sscanf( psz_line, "%u:%u:%u%c%u ", &h, &m, &s, &c, &f ) != 5 ||
2379 ( c != ':' && c != ';' ) )
2380 continue;
2381
2382 /* convert everything to seconds */
2383 uint64_t i_frames = h * 3600 + m * 60 + s;
2384
2385 if( c == ';' && p_rate->b_drop_allowed ) /* dropframe */
2386 {
2387 /* convert to frame # to be accurate between inter drop drift
2388 * of 18 frames see http://andrewduncan.net/timecodes/ */
2389 const unsigned i_mins = h * 60 + m;
2390 i_frames = i_frames * p_rate[+1].rate.num + f
2391 - (p_rate[+1].rate.den * 2 * (i_mins - i_mins % 10));
2392 }
2393 else
2394 {
2395 /* convert to frame # at 29.97 */
2396 i_frames = i_frames * framerates[3].rate.num / framerates[3].rate.den + f;
2397 }
2398 p_subtitle->i_start = VLC_TICK_0 + vlc_tick_from_sec(i_frames)*
2399 p_rate->rate.den / p_rate->rate.num;
2400 p_subtitle->i_stop = -1;
2401
2402 const char *psz_text = strchr( psz_line, '\t' );
2403 if( !psz_text && !(psz_text = strchr( psz_line, ' ' )) )
2404 continue;
2405
2406 if ( psz_text[1] == '\0' )
2407 continue;
2408
2409 p_subtitle->psz_text = strdup( psz_text + 1 );
2410 if( !p_subtitle->psz_text )
2411 return VLC_ENOMEM;
2412
2413 break;
2414 }
2415
2416 return VLC_SUCCESS;
2417 }
2418
2419 /* Matches filename.xx.srt */
2420 static char * get_language_from_filename( const char * psz_sub_file )
2421 {
2422 char *psz_ret = NULL;
2423 char *psz_tmp, *psz_language_begin;
2424
2425 if( !psz_sub_file ) return NULL;
2426 char *psz_work = strdup( psz_sub_file );
2427
2428 /* Removing extension, but leaving the dot */
2429 psz_tmp = strrchr( psz_work, '.' );
2430 if( psz_tmp )
2431 {
2432 psz_tmp[0] = '\0';
2433 psz_language_begin = strrchr( psz_work, '.' );
2434 if( psz_language_begin )
2435 psz_ret = strdup(++psz_language_begin);
2436 psz_tmp[0] = '.';
2437 }
2438
2439 free( psz_work );
2440 return psz_ret;
2441 }
VLC Development tree mirror