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