video.c: don't display pre-rolled pictures
[vlc.git] / src / input / subtitles.c
1 /*****************************************************************************
2  * subtitles.c
3  *****************************************************************************
4  * Copyright (C) 2003-2004 VideoLAN
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., 59 Temple Place - Suite 330, Boston, MA  02111, 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
34 #ifdef HAVE_DIRENT_H
35 #   include <dirent.h>
36 #endif
37
38 #include <ctype.h>
39
40 /**
41  * What's between a directory and a filename?
42  */
43 #if defined( WIN32 )
44     #define DIRECTORY_SEPARATOR '\\'
45 #else
46     #define DIRECTORY_SEPARATOR '/'
47 #endif
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 extentions 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         strcpy(d, s);
94         return;
95     }
96     else
97     {
98         strncpy(d, s, tmp - s);
99         d[tmp - s] = 0;
100     }
101     while( *d )
102     {
103         *d = tolower(*d);
104         d++;
105     }
106 }
107
108 static void strcpy_get_ext( char *d, char *s )
109 {
110     char *tmp = strrchr(s, '.');
111     if( !tmp )
112     {
113         strcpy(d, "");
114         return;
115     } else strcpy( d, tmp + 1 );
116 }
117
118 static int whiteonly( char *s )
119 {
120   while ( *s )
121   {
122         if( isalnum( *s ) ) return 0;
123         s++;
124   }
125   return 1;
126 }
127
128 typedef struct _subfn
129 {
130     int priority;
131     char *psz_fname;
132     char *psz_ext;
133 } subfn;
134
135 static int compare_sub_priority( const void *a, const void *b )
136 {
137     if (((subfn*)a)->priority > ((subfn*)b)->priority)
138     {
139         return -1;
140     }
141
142     if (((subfn*)a)->priority < ((subfn*)b)->priority)
143     {
144         return 1;
145     }
146
147 #ifndef UNDER_CE
148     return strcoll(((subfn*)a)->psz_fname, ((subfn*)b)->psz_fname);
149 #else
150     return strcmp(((subfn*)a)->psz_fname, ((subfn*)b)->psz_fname);
151 #endif
152 }
153
154 /**
155  * Convert a list of paths separated by ',' to a char**
156  */
157 static char **paths_to_list( char *psz_dir, char *psz_path )
158 {
159     unsigned int i, k, i_nb_subdirs;
160     char **subdirs; /* list of subdirectories to look in */
161     
162     i_nb_subdirs = 1;
163     for( k = 0; k < strlen( psz_path ); k++ )
164     {
165         if( psz_path[k] == ',' )
166         {
167             i_nb_subdirs++;
168         }
169     }
170                                                                                                                             
171     if( i_nb_subdirs > 0 )
172     {
173         char *psz_parser, *psz_temp;
174                                                                                                                             
175         subdirs = (char**)malloc( sizeof(char*) * ( i_nb_subdirs + 1 ) );
176         memset( subdirs, 0, sizeof(char*) * ( i_nb_subdirs + 1 ) );
177         i = 0;
178         psz_parser = psz_path;
179         while( psz_parser && *psz_parser )
180         {
181             char *psz_subdir;
182             psz_subdir = psz_parser;
183             psz_parser = strchr( psz_subdir, ',' );
184             if( psz_parser )
185             {
186                 *psz_parser = '\0';
187                 psz_parser++;
188                 while( *psz_parser == ' ' )
189                 {
190                     psz_parser++;
191                 }
192             }
193             if( strlen( psz_subdir ) > 0 )
194             {
195                 psz_temp = (char *)malloc( strlen(psz_dir)
196                                            + strlen(psz_subdir) + 2 );
197                 if( psz_temp )
198                 {
199                     sprintf( psz_temp, "%s%s%c", 
200                              psz_subdir[0] == '.' ? psz_dir : "", 
201                              psz_subdir,
202                              psz_subdir[strlen(psz_subdir) - 1] == 
203                               DIRECTORY_SEPARATOR ? '\0' : DIRECTORY_SEPARATOR );
204                     subdirs[i] = psz_temp;
205                     i++;
206                 }
207             }
208         }
209         subdirs[i] = NULL;
210     }
211     else
212     {
213         subdirs = NULL;
214     }
215     return subdirs;
216 }
217
218 /**
219  * Detect subtitle files.
220  *
221  * When called this function will split up the psz_fname string into a
222  * directory, filename and extension. It then opens the directory
223  * in which the file resides and tries to find possible matches of
224  * subtitles files.
225  *
226  * \ingroup Demux
227  * \param p_this the calling \ref input_thread_t
228  * \param psz_path a list of subdirectories (separated by a ',') to look in.
229  * \param psz_fname the complete filename to base the search on.
230  * \return a NULL terminated array of filenames with detected possible subtitles.
231  * The array contains max MAX_SUBTITLE_FILES items and you need to free it after use.
232  */
233 char **subtitles_Detect( input_thread_t *p_this, char *psz_path,
234                          char *psz_fname )
235 {
236     /* variables to be used for derivatives of psz_fname */
237     char *f_dir, *f_fname, *f_fname_noext, *f_fname_trim, *tmp;
238     /* variables to be used for derivatives FILE *f */
239     char *tmp_fname_noext, *tmp_fname_trim, *tmp_fname_ext, *tmpresult;
240     vlc_value_t fuzzy;
241     int len, i, j, i_sub_count, i_result2;
242     subfn *result; /* unsorted results */
243     char **result2; /* sorted results */
244     char **tmp_subdirs, **subdirs; /* list of subdirectories to look in */
245
246     FILE *f;
247     DIR *d;
248     struct dirent *de;
249
250     if( !strncmp( psz_fname, "file://", 7 ) )
251     {
252         psz_fname += 7;
253     }
254
255     i_sub_count = 0;
256     len = strlen( psz_fname ) > 256 ? strlen( psz_fname ) : 256;
257
258     f_dir = (char*)malloc(len);
259     f_fname = (char*)malloc(len);
260     f_fname_noext = (char*)malloc(len);
261     f_fname_trim = (char*)malloc(len);
262
263     tmp_fname_noext = (char*)malloc(len);
264     tmp_fname_trim = (char*)malloc(len);
265     tmp_fname_ext = (char*)malloc(len);
266
267     tmpresult = (char*)malloc(len);
268
269     result = (subfn*)malloc( sizeof(subfn) * MAX_SUBTITLE_FILES );
270     memset( result, 0, sizeof(subfn) * MAX_SUBTITLE_FILES );
271
272     /* extract filename & dirname from psz_fname */
273     tmp = strrchr( psz_fname, DIRECTORY_SEPARATOR );
274     if( tmp )
275     {
276         int pos;
277         strncpy( f_fname, tmp + 1, len - 1 );
278         f_fname[len - 1] = 0;
279         pos = tmp - psz_fname + 1;
280         strncpy( f_dir, psz_fname, __MIN(pos,len-1) );
281         f_dir[__MIN(pos,len-1)] = 0;
282     }
283     else
284     {
285         strncpy( f_fname, psz_fname, len - 1 );
286         f_fname[len - 1] = 0;
287         strcpy( f_dir, "" );
288     }
289
290     strcpy_strip_ext( f_fname_noext, f_fname );
291     strcpy_trim( f_fname_trim, f_fname_noext );
292     var_Get( p_this, "sub-autodetect-fuzzy", &fuzzy );
293
294     tmp_subdirs = paths_to_list( f_dir, psz_path );
295     subdirs = tmp_subdirs;
296
297     for( j = -1; j == -1 || ( j >= 0 && subdirs != NULL && *subdirs != NULL );
298          j++)
299     {
300         d = opendir( j < 0 ? f_dir : *subdirs );
301         if( d )
302         {
303             int b_found;
304             msg_Dbg( p_this, "looking for a subtitle file in %s", 
305                      j < 0 ? f_dir : *subdirs );
306             while( ( de = readdir( d ) ) )
307             {
308                 /* retrieve various parts of the filename */
309                 strcpy_strip_ext( tmp_fname_noext, de->d_name );
310                 strcpy_get_ext( tmp_fname_ext, de->d_name );
311                 strcpy_trim( tmp_fname_trim, tmp_fname_noext );
312
313                 /* does it end with a subtitle extension? */
314                 b_found = 0;
315                 for( i = 0; sub_exts[i]; i++ )
316                 {
317                     if( strcmp( sub_exts[i], tmp_fname_ext ) == 0 )
318                     {
319                         b_found = 1;
320                         msg_Dbg( p_this, "found a possible subtitle: %s",
321                                  de->d_name );
322                         break;
323                     }
324                 }
325
326                 /* we have a (likely) subtitle file */
327                 if( b_found )
328                 {
329                     int i_prio = 0;
330                     if( !i_prio && !strcmp( tmp_fname_trim, f_fname_trim ) )
331                     {
332                         /* matches the movie name exactly */
333                         i_prio = 4;
334                     }
335                     if( !i_prio &&
336                         ( tmp = strstr( tmp_fname_trim, f_fname_trim ) ) )
337                     {
338                         /* contains the movie name */
339                         tmp += strlen( f_fname_trim );
340                         if( whiteonly( tmp ) )
341                         {
342                             /* chars in front of the movie name */
343                             i_prio = 2;
344                         }
345                         else
346                         {
347                             /* chars after (and possibly in front of)
348                              * the movie name */
349                             i_prio = 3;
350                         }
351                     }
352                     if( !i_prio )
353                     {
354                         /* doesn't contain the movie name */
355                         if( j == 0 ) i_prio = 1;
356                     }
357
358                     if( i_prio >= fuzzy.i_int )
359                     {
360                         sprintf( tmpresult, "%s%s", j == -1 ? f_dir : *subdirs,
361                                  de->d_name );
362                         msg_Dbg( p_this, "autodetected subtitle: %s with "
363                                  "priority %d", de->d_name, i_prio );
364                         if( ( f = fopen( tmpresult, "rt" ) ) )
365                         {
366                             fclose( f );
367                             result[i_sub_count].priority = i_prio;
368                             result[i_sub_count].psz_fname = strdup(tmpresult);
369                             result[i_sub_count].psz_ext = strdup(tmp_fname_ext);
370                             i_sub_count++;
371                         }
372                     }
373                 }
374                 if( i_sub_count >= MAX_SUBTITLE_FILES ) break;
375             }
376             closedir( d );
377         }
378         if( j >= 0 ) free( *subdirs++ );
379     }
380
381     if( tmp_subdirs ) free( tmp_subdirs );
382
383     free( f_dir );
384     free( f_fname );
385     free( f_fname_noext );
386     free( f_fname_trim );
387
388     free( tmp_fname_noext );
389     free( tmp_fname_trim );
390     free( tmp_fname_ext );
391
392     free( tmpresult );
393
394     qsort( result, i_sub_count, sizeof( subfn ), compare_sub_priority );
395
396     result2 = (char**)malloc( sizeof(char*) * ( i_sub_count + 1 ) );
397     memset( result2, 0, sizeof(char*) * ( i_sub_count + 1 ) );
398     i_result2 = 0;
399
400     for( i = 0; i < i_sub_count; i++ )
401     {
402         if( result[i].psz_ext && !strcasecmp( result[i].psz_ext, "sub" ) )
403         {
404             int j;
405             for( j = 0; j < i_sub_count; j++ )
406             {
407                 if( result[j].psz_fname && result[i].psz_fname &&
408                     !strncasecmp( result[i].psz_fname, result[j].psz_fname, sizeof( result[i].psz_fname) - 4 ) && 
409                     !strcasecmp( result[j].psz_ext, "idx" ) )
410                     break;
411                 
412             }
413             if( j >= i_sub_count )
414             {
415                 result2[i_result2] = result[i].psz_fname;
416                 i_result2++;
417             }
418         }
419         else
420         {
421             result2[i_result2] = result[i].psz_fname;
422             i_result2++;
423         }
424     }
425     free( result );
426     return result2;
427 }