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