Added CD+G file support:
[vlc.git] / src / input / subtitles.c
1 /*****************************************************************************
2  * subtitles.c
3  *****************************************************************************
4  * Copyright (C) 2003-2006 the VideoLAN team
5  * $Id$
6  *
7  * Authors: Derk-Jan Hartman <hartman at videolan.org>
8  * This is adapted code from the GPL'ed MPlayer (http://mplayerhq.hu)
9  *
10  * This program is free software; you can redistribute it and/or modify
11  * it under the terms of the GNU General Public License as published by
12  * the Free Software Foundation; either version 2 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 General Public License for more details.
19  *
20  * You should have received a copy of the GNU General Public License
21  * along with this program; if not, write to the Free Software
22  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston MA 02110-1301, USA.
23  *****************************************************************************/
24
25 /**
26  *  \file
27  *  This file contains functions to dectect subtitle files.
28  */
29
30 #include <vlc/vlc.h>
31 #include <vlc_input.h>
32 #include <vlc_charset.h>
33
34 #ifdef HAVE_DIRENT_H
35 #   include <dirent.h>
36 #endif
37
38 #ifdef HAVE_LIMITS_H
39 #   include <limits.h>
40 #endif
41
42 #ifdef HAVE_UNISTD_H
43 #   include <unistd.h>
44 #endif
45 #include <sys/stat.h>
46
47 #include <ctype.h>
48 #include "input_internal.h"
49
50 /**
51  * We are not going to autodetect more subtitle files than this.
52  */
53 #define MAX_SUBTITLE_FILES 128
54
55
56 /**
57  * The possible extensions for subtitle files we support
58  */
59 static const char const sub_exts[][6] = {
60     "utf", "utf8", "utf-8",
61     "sub", "srt", "smi",
62     "txt", "ssa", "idx",
63
64     "cdg",
65
66     ""
67 };
68
69 /* extensions from unsupported types */
70 /* rt, aqt, jss, js, ass */
71
72 static void strcpy_trim( char *d, char *s )
73 {
74     /* skip leading whitespace */
75     while( *s && !isalnum(*s) )
76     {
77         s++;
78     }
79     for(;;)
80     {
81         /* copy word */
82         while( *s && isalnum(*s) )
83         {
84             *d = tolower(*s);
85             s++; d++;
86         }
87         if( *s == 0 ) break;
88         /* trim excess whitespace */
89         while( *s && !isalnum(*s) )
90         {
91             s++;
92         }
93         if( *s == 0 ) break;
94         *d++ = ' ';
95     }
96     *d = 0;
97 }
98
99 static void strcpy_strip_ext( char *d, char *s )
100 {
101     char *tmp = strrchr(s, '.');
102     if( !tmp )
103     {
104         strcpy(d, s);
105         return;
106     }
107     else
108         strlcpy(d, s, tmp - s + 1 );
109     while( *d )
110     {
111         *d = tolower(*d);
112         d++;
113     }
114 }
115
116 static void strcpy_get_ext( char *d, char *s )
117 {
118     char *tmp = strrchr(s, '.');
119     if( !tmp )
120     {
121         strcpy(d, "");
122         return;
123     } else strcpy( d, tmp + 1 );
124 }
125
126 static int whiteonly( char *s )
127 {
128   while ( *s )
129   {
130         if( isalnum( *s ) ) return 0;
131         s++;
132   }
133   return 1;
134 }
135
136 typedef struct _subfn
137 {
138     int priority;
139     char *psz_fname;
140     char *psz_ext;
141 } subfn;
142
143 static int compare_sub_priority( const void *a, const void *b )
144 {
145     if (((subfn*)a)->priority > ((subfn*)b)->priority)
146     {
147         return -1;
148     }
149
150     if (((subfn*)a)->priority < ((subfn*)b)->priority)
151     {
152         return 1;
153     }
154
155 #ifndef UNDER_CE
156     return strcoll(((subfn*)a)->psz_fname, ((subfn*)b)->psz_fname);
157 #else
158     return strcmp(((subfn*)a)->psz_fname, ((subfn*)b)->psz_fname);
159 #endif
160 }
161
162 /*
163  * Check if a file ends with a subtitle extension
164  */
165 int subtitles_Filter( const char *psz_dir_content )
166 {
167     const char *tmp = strrchr( psz_dir_content, '.');
168     if( tmp == NULL )
169         return 0;
170     else
171     {
172         int i;
173         tmp++;
174
175         for( i = 0; sub_exts[i][0]; i++ )
176             if( strcasecmp( sub_exts[i], tmp ) == 0 )
177                 return 1;
178     }
179     return 0;
180 }
181
182
183 /**
184  * Convert a list of paths separated by ',' to a char**
185  */
186 static char **paths_to_list( const char *psz_dir, char *psz_path )
187 {
188     unsigned int i, k, i_nb_subdirs;
189     char **subdirs; /* list of subdirectories to look in */
190
191     if( !psz_dir ) return NULL;
192     if( !psz_path ) return NULL;
193
194     i_nb_subdirs = 1;
195     for( k = 0; k < strlen( psz_path ); k++ )
196     {
197         if( psz_path[k] == ',' )
198         {
199             i_nb_subdirs++;
200         }
201     }
202
203     if( i_nb_subdirs > 0 )
204     {
205         char *psz_parser = NULL, *psz_temp = NULL;
206
207         subdirs = (char**)malloc( sizeof(char*) * ( i_nb_subdirs + 1 ) );
208         memset( subdirs, 0, sizeof(char*) * ( i_nb_subdirs + 1 ) );
209         i = 0;
210         psz_parser = psz_path;
211         while( psz_parser && *psz_parser )
212         {
213             char *psz_subdir;
214             psz_subdir = psz_parser;
215             psz_parser = strchr( psz_subdir, ',' );
216             if( psz_parser )
217             {
218                 *psz_parser = '\0';
219                 psz_parser++;
220                 while( *psz_parser == ' ' )
221                 {
222                     psz_parser++;
223                 }
224             }
225             if( strlen( psz_subdir ) > 0 )
226             {
227                 psz_temp = (char *)malloc( strlen(psz_dir)
228                                            + strlen(psz_subdir) + 2 );
229                 if( psz_temp )
230                 {
231                     sprintf( psz_temp, "%s%s%c",
232                              psz_subdir[0] == '.' ? psz_dir : "",
233                              psz_subdir,
234                              psz_subdir[strlen(psz_subdir) - 1] ==
235                               DIR_SEP_CHAR ? '\0' : DIR_SEP_CHAR );
236                     subdirs[i] = psz_temp;
237                     i++;
238                 }
239             }
240         }
241         subdirs[i] = NULL;
242     }
243     else
244     {
245         subdirs = NULL;
246     }
247     return subdirs;
248 }
249
250
251 /**
252  * Detect subtitle files.
253  *
254  * When called this function will split up the psz_name string into a
255  * directory, filename and extension. It then opens the directory
256  * in which the file resides and tries to find possible matches of
257  * subtitles files.
258  *
259  * \ingroup Demux
260  * \param p_this the calling \ref input_thread_t
261  * \param psz_path a list of subdirectories (separated by a ',') to look in.
262  * \param psz_name the complete filename to base the search on.
263  * \return a NULL terminated array of filenames with detected possible subtitles.
264  * The array contains max MAX_SUBTITLE_FILES items and you need to free it after use.
265  */
266 char **subtitles_Detect( input_thread_t *p_this, char *psz_path,
267                          const char *psz_name )
268 {
269     vlc_value_t fuzzy;
270     int j, i_result2, i_sub_count = 0, i_fname_len = 0;
271     char *f_dir = NULL, *f_fname = NULL, *f_fname_noext = NULL, *f_fname_trim = NULL;
272     char *tmp = NULL;
273
274     char **tmp_subdirs, **subdirs; /* list of subdirectories to look in */
275
276     subfn *result = NULL; /* unsorted results */
277     char **result2; /* sorted results */
278
279     char *psz_fname_original = strdup( psz_name );
280     char *psz_fname = psz_fname_original;
281
282     if( psz_fname == NULL ) return NULL;
283
284     if( !strncmp( psz_fname, "file://", 7 ) )
285     {
286         psz_fname += 7;
287     }
288
289     /* extract filename & dirname from psz_fname */
290     tmp = strrchr( psz_fname, DIR_SEP_CHAR );
291     if( tmp )
292     {
293         int dirlen = 0;
294
295         f_fname = malloc( strlen(tmp) );
296         if( f_fname )
297             strcpy( f_fname, tmp+1 ); // we skip the separator, so it will still fit in the allocated space
298         dirlen = strlen(psz_fname) - strlen(tmp) + 2; // add the separator
299         f_dir = malloc( dirlen + 1 );
300         if( f_dir != NULL )
301             strlcpy( f_dir, psz_fname, dirlen );
302     }
303     else
304     {
305         /* Get the current working directory */
306         int dirlen;
307 #ifdef HAVE_UNISTD_H
308         f_dir = getcwd( NULL, 0 );
309 #endif
310         if( f_dir == NULL )
311         {
312             if( psz_fname_original ) free( psz_fname_original );
313             return NULL;
314         }
315         dirlen = strlen( f_dir );
316         f_dir = (char *)realloc(f_dir, dirlen +2 );
317         f_dir[dirlen] = DIR_SEP_CHAR;
318         f_dir[dirlen+1] = '\0';
319         f_fname = strdup( psz_fname );
320     }
321
322     i_fname_len = strlen( f_fname );
323     f_fname_noext = malloc(i_fname_len + 1);
324     f_fname_trim = malloc(i_fname_len + 1 );
325
326     strcpy_strip_ext( f_fname_noext, f_fname );
327     strcpy_trim( f_fname_trim, f_fname_noext );
328
329     result = (subfn*)malloc( sizeof(subfn) * MAX_SUBTITLE_FILES );
330     if( result )
331         memset( result, 0, sizeof(subfn) * MAX_SUBTITLE_FILES );
332
333     var_Get( p_this, "sub-autodetect-fuzzy", &fuzzy );
334
335     tmp_subdirs = paths_to_list( f_dir, psz_path );
336     subdirs = tmp_subdirs;
337
338     for( j = -1; (j == -1) || ( (j >= 0) && (subdirs != NULL) &&
339         (*subdirs != NULL) ); j++)
340     {
341         const char *psz_dir = j < 0 ? f_dir : *subdirs;
342         char **ppsz_dir_content;
343         int i_dir_content;
344
345         if( psz_dir == NULL )
346             continue;
347
348         /* parse psz_src dir */
349         i_dir_content = utf8_scandir( psz_dir, &ppsz_dir_content,
350                                       subtitles_Filter, NULL );
351
352         if( i_dir_content != -1 )
353         {
354             int a;
355
356             msg_Dbg( p_this, "looking for a subtitle file in %s", psz_dir );
357             for( a = 0; a < i_dir_content; a++ )
358             {
359                 char *psz_name = ppsz_dir_content[a];
360                 char tmp_fname_noext[strlen( psz_name ) + 1];
361                 char tmp_fname_trim[strlen( psz_name ) + 1];
362                 char tmp_fname_ext[strlen( psz_name ) + 1];
363
364                 int i_prio = 0;
365
366                 if( psz_name == NULL )
367                     continue;
368
369                 /* retrieve various parts of the filename */
370                 strcpy_strip_ext( tmp_fname_noext, psz_name );
371                 strcpy_get_ext( tmp_fname_ext, psz_name );
372                 strcpy_trim( tmp_fname_trim, tmp_fname_noext );
373
374                 if( !i_prio && !strcmp( tmp_fname_trim, f_fname_trim ) )
375                 {
376                     /* matches the movie name exactly */
377                     i_prio = 4;
378                 }
379                 if( !i_prio &&
380                     ( tmp = strstr( tmp_fname_trim, f_fname_trim ) ) )
381                 {
382                     /* contains the movie name */
383                     tmp += strlen( f_fname_trim );
384                     if( whiteonly( tmp ) )
385                     {
386                         /* chars in front of the movie name */
387                         i_prio = 2;
388                     }
389                     else
390                     {
391                         /* chars after (and possibly in front of)
392                          * the movie name */
393                         i_prio = 3;
394                     }
395                 }
396                 if( !i_prio )
397                 {
398                     /* doesn't contain the movie name */
399                     if( j == 0 ) i_prio = 1;
400                 }
401                 if( i_prio >= fuzzy.i_int )
402                 {
403                     char psz_path[strlen( psz_dir ) + strlen( psz_name ) + 1];
404                     struct stat st;
405
406                     sprintf( psz_path, "%s%s", psz_dir, psz_name );
407                     if( !strcmp( psz_path, psz_fname ) )
408                         continue;
409
410                     msg_Dbg( p_this,
411                                 "autodetected subtitle: %s with priority %d",
412                                 psz_path, i_prio );
413
414                     if( !utf8_stat( psz_path, &st ) && S_ISREG( st.st_mode ) )
415                     {
416                         msg_Dbg( p_this,
417                                 "autodetected subtitle: %s with priority %d",
418                                 psz_path, i_prio );
419                         result[i_sub_count].priority = i_prio;
420                         result[i_sub_count].psz_fname = strdup( psz_path );
421                         result[i_sub_count].psz_ext = strdup(tmp_fname_ext);
422                         i_sub_count++;
423                     }
424                     else
425                     {
426                         msg_Dbg( p_this, "stat failed" );
427                     }
428                 }
429                 if( i_sub_count >= MAX_SUBTITLE_FILES ) break;
430             }
431             for( a = 0; a < i_dir_content; a++ )
432                 free( ppsz_dir_content[a] );
433             if( ppsz_dir_content ) free( ppsz_dir_content );
434         }
435         if( j >= 0 ) if( *subdirs ) free( *subdirs++ );
436     }
437
438     if( tmp_subdirs )   free( tmp_subdirs );
439     if( f_fname_trim )  free( f_fname_trim );
440     if( f_fname_noext ) free( f_fname_noext );
441     if( f_fname ) free( f_fname );
442     if( f_dir )   free( f_dir );
443
444     qsort( result, i_sub_count, sizeof( subfn ), compare_sub_priority );
445
446     result2 = (char**)malloc( sizeof(char*) * ( i_sub_count + 1 ) );
447     if( result2 )
448         memset( result2, 0, sizeof(char*) * ( i_sub_count + 1 ) );
449     i_result2 = 0;
450
451     for( j = 0; j < i_sub_count; j++ )
452     {
453         if( result[j].psz_ext && !strcasecmp( result[j].psz_ext, "sub" ) )
454         {
455             int i;
456             for( i = 0; i < i_sub_count; i++ )
457             {
458                 if( result[i].psz_fname && result[j].psz_fname &&
459                     !strncasecmp( result[j].psz_fname, result[i].psz_fname,
460                                 sizeof( result[j].psz_fname) - 4 ) &&
461                     !strcasecmp( result[i].psz_ext, "idx" ) )
462                     break;
463             }
464             if( i >= i_sub_count )
465             {
466                 result2[i_result2] = result[j].psz_fname;
467                 i_result2++;
468             }
469         }
470         else if( result[j].psz_ext && !strcasecmp( result[j].psz_ext, "cdg" ) )
471         {
472             if( result[j].priority == 4 )
473             {
474                 result2[i_result2] = result[j].psz_fname;
475                 i_result2++;
476             }
477         }
478         else
479         {
480             result2[i_result2] = result[j].psz_fname;
481             i_result2++;
482         }
483     }
484
485     if( psz_fname_original ) free( psz_fname_original );
486     if( result ) free( result );
487     return result2;
488 }