git.sesse.net Git - vlc/blob - src/input/subtitles.c

   1 /*****************************************************************************
   2  * subtitles.c
   3  *****************************************************************************
   4  * Copyright (C) 2003-2004 VideoLAN (Centrale Réseaux) and its contributors
   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 }