apps/filetypes.c

   1 /***************************************************************************
   2  *             __________               __   ___.
   3  *   Open      \______   \ ____   ____ |  | _\_ |__   _______  ___
   4  *   Source     |       _//  _ \_/ ___\|  |/ /| __ \ /  _ \  \/  /
   5  *   Jukebox    |    |   (  <_> )  \___|    < | \_\ (  <_> > <  <
   6  *   Firmware   |____|_  /\____/ \___  >__|_ \|___  /\____/__/\_ \
   7  *
   8  * $Id$
   9  *
  10  * Copyright (C) 2007 Jonathan Gordon
  11  *
  12  * This program is free software; you can redistribute it and/or
  13  * modify it under the terms of the GNU General Public License
  14  * as published by the Free Software Foundation; either version 2
  15  * of the License, or (at your option) any later version.
  16  *
  17  * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY
  18  * KIND, either express or implied.
  19  *
  20  ****************************************************************************/
  21
  22 #include <stdio.h>
  23 #include <string.h>
  24 #include <stdlib.h>
  25 #include <stdbool.h>
  26 #include "string.h"
  27 #include <ctype.h>
  28
  29 #include "settings.h"
  30 #include "debug.h"
  31 #include "lang.h"
  32 #include "kernel.h"
  33 #include "plugin.h"
  34 #include "filetypes.h"
  35 #include "screens.h"
  36 #include "dir.h"
  37 #include "file.h"
  38 #include "splash.h"
  39 #include "buffer.h"
  40 #include "icons.h"
  41 #include "logf.h"
  42
  43 /* max filetypes (plugins & icons stored here) */
  44 #if CONFIG_CODEC == SWCODEC
  45 #define MAX_FILETYPES 192
  46 #else
  47 #define MAX_FILETYPES 128
  48 #endif
  49 /* max viewer plugins */
  50 #ifdef HAVE_LCD_BITMAP
  51 #define MAX_VIEWERS 56
  52 #else
  53 #define MAX_VIEWERS 24
  54 #endif
  55
  56 /* a table for the known file types */
  57 static const struct filetype inbuilt_filetypes[] = {
  58     { "mp3", FILE_ATTR_AUDIO, Icon_Audio, VOICE_EXT_MPA },
  59     { "mp2", FILE_ATTR_AUDIO, Icon_Audio, VOICE_EXT_MPA },
  60     { "mpa", FILE_ATTR_AUDIO, Icon_Audio, VOICE_EXT_MPA },
  61 #if CONFIG_CODEC == SWCODEC
  62     /* Temporary hack to allow playlist creation */
  63     { "mp1", FILE_ATTR_AUDIO, Icon_Audio, VOICE_EXT_MPA },
  64     { "ogg", FILE_ATTR_AUDIO, Icon_Audio, VOICE_EXT_MPA },
  65     { "oga", FILE_ATTR_AUDIO, Icon_Audio, VOICE_EXT_MPA },
  66     { "wma", FILE_ATTR_AUDIO, Icon_Audio, VOICE_EXT_MPA },
  67     { "wmv", FILE_ATTR_AUDIO, Icon_Audio, VOICE_EXT_MPA },
  68     { "asf", FILE_ATTR_AUDIO, Icon_Audio, VOICE_EXT_MPA },
  69     { "wav", FILE_ATTR_AUDIO, Icon_Audio, VOICE_EXT_MPA },
  70     { "flac",FILE_ATTR_AUDIO, Icon_Audio, VOICE_EXT_MPA },
  71     { "ac3", FILE_ATTR_AUDIO, Icon_Audio, VOICE_EXT_MPA },
  72     { "a52", FILE_ATTR_AUDIO, Icon_Audio, VOICE_EXT_MPA },
  73     { "mpc", FILE_ATTR_AUDIO, Icon_Audio, VOICE_EXT_MPA },
  74     { "wv",  FILE_ATTR_AUDIO, Icon_Audio, VOICE_EXT_MPA },
  75     { "m4a", FILE_ATTR_AUDIO, Icon_Audio, VOICE_EXT_MPA },
  76     { "m4b", FILE_ATTR_AUDIO, Icon_Audio, VOICE_EXT_MPA },
  77     { "mp4", FILE_ATTR_AUDIO, Icon_Audio, VOICE_EXT_MPA },
  78     { "mod", FILE_ATTR_AUDIO, Icon_Audio, VOICE_EXT_MPA },
  79     { "shn", FILE_ATTR_AUDIO, Icon_Audio, VOICE_EXT_MPA },
  80     { "aif", FILE_ATTR_AUDIO, Icon_Audio, VOICE_EXT_MPA },
  81     { "aiff",FILE_ATTR_AUDIO, Icon_Audio, VOICE_EXT_MPA },
  82     { "spx" ,FILE_ATTR_AUDIO, Icon_Audio, VOICE_EXT_MPA },
  83     { "sid", FILE_ATTR_AUDIO, Icon_Audio, VOICE_EXT_MPA },
  84     { "adx", FILE_ATTR_AUDIO, Icon_Audio, VOICE_EXT_MPA },
  85     { "nsf", FILE_ATTR_AUDIO, Icon_Audio, VOICE_EXT_MPA },
  86     { "nsfe",FILE_ATTR_AUDIO, Icon_Audio, VOICE_EXT_MPA },
  87     { "spc", FILE_ATTR_AUDIO, Icon_Audio, VOICE_EXT_MPA },
  88     { "ape", FILE_ATTR_AUDIO, Icon_Audio, VOICE_EXT_MPA },
  89     { "mac", FILE_ATTR_AUDIO, Icon_Audio, VOICE_EXT_MPA },
  90     { "sap" ,FILE_ATTR_AUDIO, Icon_Audio, VOICE_EXT_MPA },
  91     { "rm",  FILE_ATTR_AUDIO, Icon_Audio, VOICE_EXT_MPA },
  92     { "ra",  FILE_ATTR_AUDIO, Icon_Audio, VOICE_EXT_MPA },
  93     { "rmvb",FILE_ATTR_AUDIO, Icon_Audio, VOICE_EXT_MPA },
  94     { "cmc", FILE_ATTR_AUDIO, Icon_Audio, VOICE_EXT_MPA },
  95     { "cm3", FILE_ATTR_AUDIO, Icon_Audio, VOICE_EXT_MPA },
  96     { "cmr", FILE_ATTR_AUDIO, Icon_Audio, VOICE_EXT_MPA },
  97     { "cms", FILE_ATTR_AUDIO, Icon_Audio, VOICE_EXT_MPA },
  98     { "dmc", FILE_ATTR_AUDIO, Icon_Audio, VOICE_EXT_MPA },
  99     { "dlt", FILE_ATTR_AUDIO, Icon_Audio, VOICE_EXT_MPA },
 100     { "mpt", FILE_ATTR_AUDIO, Icon_Audio, VOICE_EXT_MPA },
 101     { "mpd", FILE_ATTR_AUDIO, Icon_Audio, VOICE_EXT_MPA },
 102     { "rmt", FILE_ATTR_AUDIO, Icon_Audio, VOICE_EXT_MPA },
 103     { "tmc", FILE_ATTR_AUDIO, Icon_Audio, VOICE_EXT_MPA },
 104     { "tm8", FILE_ATTR_AUDIO, Icon_Audio, VOICE_EXT_MPA },
 105     { "tm2", FILE_ATTR_AUDIO, Icon_Audio, VOICE_EXT_MPA },
 106     { "oma", FILE_ATTR_AUDIO, Icon_Audio, VOICE_EXT_MPA },
 107     { "aa3", FILE_ATTR_AUDIO, Icon_Audio, VOICE_EXT_MPA },
 108     { "at3", FILE_ATTR_AUDIO, Icon_Audio, VOICE_EXT_MPA },
 109     { "mmf", FILE_ATTR_AUDIO, Icon_Audio, VOICE_EXT_MPA },
 110     { "au",  FILE_ATTR_AUDIO, Icon_Audio, VOICE_EXT_MPA },
 111     { "snd", FILE_ATTR_AUDIO, Icon_Audio, VOICE_EXT_MPA },
 112     { "vox", FILE_ATTR_AUDIO, Icon_Audio, VOICE_EXT_MPA },
 113     { "w64", FILE_ATTR_AUDIO, Icon_Audio, VOICE_EXT_MPA },
 114     { "tta", FILE_ATTR_AUDIO, Icon_Audio, VOICE_EXT_MPA },
 115 #endif
 116     { "m3u", FILE_ATTR_M3U, Icon_Playlist, LANG_PLAYLIST },
 117     { "m3u8",FILE_ATTR_M3U, Icon_Playlist, LANG_PLAYLIST },
 118     { "cfg", FILE_ATTR_CFG, Icon_Config,   VOICE_EXT_CFG },
 119     { "wps", FILE_ATTR_WPS, Icon_Wps,      VOICE_EXT_WPS },
 120 #ifdef HAVE_REMOTE_LCD
 121     { "rwps",FILE_ATTR_RWPS, Icon_Wps,     VOICE_EXT_RWPS },
 122 #endif
 123 #if CONFIG_TUNER
 124     { "fmr", FILE_ATTR_FMR, Icon_Preset, LANG_FMR },
 125     { "fms", FILE_ATTR_FMS, Icon_Wps, VOICE_EXT_FMS },
 126 #endif
 127     { "lng", FILE_ATTR_LNG, Icon_Language, LANG_LANGUAGE },
 128     { "rock",FILE_ATTR_ROCK,Icon_Plugin,   VOICE_EXT_ROCK },
 129     { "lua", FILE_ATTR_LUA, Icon_Plugin,   VOICE_EXT_ROCK },
 130 #ifdef HAVE_LCD_BITMAP
 131     { "fnt", FILE_ATTR_FONT,Icon_Font,     VOICE_EXT_FONT },
 132     { "kbd", FILE_ATTR_KBD, Icon_Keyboard, VOICE_EXT_KBD },
 133 #endif
 134     { "bmark",FILE_ATTR_BMARK, Icon_Bookmark,  VOICE_EXT_BMARK },
 135     { "cue",  FILE_ATTR_CUE,   Icon_Bookmark,  VOICE_EXT_CUESHEET },
 136 #ifdef HAVE_LCD_BITMAP
 137     { "sbs",  FILE_ATTR_SBS,  Icon_Wps,   VOICE_EXT_SBS },
 138 #endif
 139 #ifdef HAVE_REMOTE_LCD
 140     { "rsbs", FILE_ATTR_RSBS, Icon_Wps,   VOICE_EXT_RSBS },
 141 #if CONFIG_TUNER
 142     { "rfms", FILE_ATTR_RFMS, Icon_Wps, VOICE_EXT_RFMS },
 143 #endif
 144 #endif
 145 #ifdef BOOTFILE_EXT
 146     { BOOTFILE_EXT, FILE_ATTR_MOD, Icon_Firmware, VOICE_EXT_AJZ },
 147 #endif
 148 #ifdef BOOTFILE_EXT2
 149     { BOOTFILE_EXT2, FILE_ATTR_MOD, Icon_Firmware, VOICE_EXT_AJZ },
 150 #endif
 151 };
 152
 153 void tree_get_filetypes(const struct filetype** types, int* count)
 154 {
 155     *types = inbuilt_filetypes;
 156     *count = sizeof(inbuilt_filetypes) / sizeof(*inbuilt_filetypes);
 157 }
 158
 159 #define ROCK_EXTENSION "rock"
 160
 161 struct file_type {
 162     int  icon; /* the icon which shall be used for it, NOICON if unknown */
 163     unsigned char  attr; /* FILE_ATTR_MASK >> 8 */
 164     char* plugin; /* Which plugin to use, NULL if unknown, or builtin */
 165     char* extension; /* NULL for none */
 166 };
 167 static struct file_type filetypes[MAX_FILETYPES];
 168 static int custom_filetype_icons[MAX_FILETYPES];
 169 static bool custom_icons_loaded = false;
 170 #ifdef HAVE_LCD_COLOR
 171 static int custom_colors[MAX_FILETYPES+1];
 172 #endif
 173 /* index array to filetypes used in open with list. */
 174 static int viewers[MAX_VIEWERS];
 175 static int filetype_count = 0;
 176 static unsigned char highest_attr = 0;
 177 static int viewer_count = 0;
 178
 179 static char *filetypes_strdup(char* string)
 180 {
 181     char *buffer = (char*)buffer_alloc(strlen(string)+1);
 182     strcpy(buffer, string);
 183     return buffer;
 184 }
 185 static char *filetypes_store_plugin(char *plugin, int n)
 186 {
 187     int i;
 188     /* if the plugin is in the list already, use it. */
 189     for (i=0; i<viewer_count; i++)
 190     {
 191         if (!strcmp(filetypes[viewers[i]].plugin, plugin))
 192             return filetypes[viewers[i]].plugin;
 193     }
 194     /* otherwise, allocate buffer */
 195     if (viewer_count < MAX_VIEWERS)
 196         viewers[viewer_count++] = n;
 197     return filetypes_strdup(plugin);
 198 }
 199 static void read_builtin_types(void);
 200 static void read_config(const char* config_file);
 201 #ifdef HAVE_LCD_COLOR
 202 /* Colors file format is similar to icons:
 203  * ext:hex_color
 204  * load a colors file from a theme with:
 205  * filetype colours: filename.colours */
 206 void read_color_theme_file(void) {
 207     char buffer[MAX_PATH], dir[MAX_PATH];
 208     int fd;
 209     char *ext, *color;
 210     int i;
 211     for (i = 0; i < MAX_FILETYPES+1; i++) {
 212         custom_colors[i] = -1;
 213     }
 214     snprintf(buffer, MAX_PATH, "%s/%s.colours",
 215              get_user_file_path(THEME_DIR, 0, dir, sizeof(dir)),
 216              global_settings.colors_file);
 217     fd = open(buffer, O_RDONLY);
 218     if (fd < 0)
 219         return;
 220     while (read_line(fd, buffer, MAX_PATH) > 0)
 221     {
 222         if (!settings_parseline(buffer, &ext, &color))
 223             continue;
 224         if (!strcasecmp(ext, "folder"))
 225         {
 226             hex_to_rgb(color, &custom_colors[0]);
 227             continue;
 228         }
 229         if (!strcasecmp(ext, "???"))
 230         {
 231             hex_to_rgb(color, &custom_colors[MAX_FILETYPES]);
 232             continue;
 233         }
 234         for (i=1; i<filetype_count; i++)
 235         {
 236             if (filetypes[i].extension &&
 237                 !strcasecmp(ext, filetypes[i].extension))
 238             {
 239                 hex_to_rgb(color, &custom_colors[i]);
 240                 break;
 241             }
 242         }
 243     }
 244     close(fd);
 245 }
 246 #endif
 247 #ifdef HAVE_LCD_BITMAP
 248 void read_viewer_theme_file(void)
 249 {
 250     char buffer[MAX_PATH];
 251     int fd;
 252     char *ext, *icon;
 253     int i;
 254     global_status.viewer_icon_count = 0;
 255     custom_icons_loaded = false;
 256     custom_filetype_icons[0] = Icon_Folder;
 257     for (i=1; i<filetype_count; i++)
 258     {
 259         custom_filetype_icons[i] = filetypes[i].icon;
 260     }
 261
 262     snprintf(buffer, MAX_PATH, "%s/%s.icons", ICON_DIR,
 263              global_settings.viewers_icon_file);
 264     fd = open(buffer, O_RDONLY);
 265     if (fd < 0)
 266         return;
 267     while (read_line(fd, buffer, MAX_PATH) > 0)
 268     {
 269         if (!settings_parseline(buffer, &ext, &icon))
 270             continue;
 271         for (i=0; i<filetype_count; i++)
 272         {
 273             if (filetypes[i].extension &&
 274                 !strcasecmp(ext, filetypes[i].extension))
 275             {
 276                 if (*icon == '*')
 277                     custom_filetype_icons[i] = atoi(icon+1);
 278                 else if (*icon == '-')
 279                     custom_filetype_icons[i] = Icon_NOICON;
 280                 else if (*icon >= '0' && *icon <= '9')
 281                 {
 282                     int number = atoi(icon);
 283                     if (number > global_status.viewer_icon_count)
 284                         global_status.viewer_icon_count++;
 285                     custom_filetype_icons[i] = Icon_Last_Themeable + number;
 286                 }
 287                 break;
 288             }
 289         }
 290     }
 291     close(fd);
 292     custom_icons_loaded = true;
 293 }
 294 #endif
 295
 296 void  filetype_init(void)
 297 {
 298     char path[MAX_PATH];
 299     /* set the directory item first */
 300     filetypes[0].extension = NULL;
 301     filetypes[0].plugin = NULL;
 302     filetypes[0].attr   = 0;
 303     filetypes[0].icon   = Icon_Folder;
 304
 305     viewer_count = 0;
 306     filetype_count = 1;
 307     read_builtin_types();
 308     read_config(get_user_file_path(VIEWERS_CONFIG, IS_FILE, path, sizeof(path)));
 309 #ifdef HAVE_LCD_BITMAP
 310     read_viewer_theme_file();
 311 #endif
 312 #ifdef HAVE_LCD_COLOR
 313     read_color_theme_file();
 314 #endif
 315 }
 316
 317 /* remove all white spaces from string */
 318 static void rm_whitespaces(char* str)
 319 {
 320     char *s = str;
 321     while (*str)
 322     {
 323         if (!isspace(*str))
 324         {
 325             *s = *str;
 326             s++;
 327         }
 328         str++;
 329     }
 330     *s = '\0';
 331 }
 332
 333 static void read_builtin_types(void)
 334 {
 335     int count = sizeof(inbuilt_filetypes)/sizeof(*inbuilt_filetypes), i;
 336     for(i=0; i<count && (filetype_count < MAX_FILETYPES); i++)
 337     {
 338         filetypes[filetype_count].extension = inbuilt_filetypes[i].extension;
 339         filetypes[filetype_count].plugin = NULL;
 340         filetypes[filetype_count].attr   = inbuilt_filetypes[i].tree_attr>>8;
 341         if (filetypes[filetype_count].attr > highest_attr)
 342             highest_attr = filetypes[filetype_count].attr;
 343         filetypes[filetype_count].icon   = inbuilt_filetypes[i].icon;
 344         filetype_count++;
 345     }
 346 }
 347
 348 static void read_config(const char* config_file)
 349 {
 350     char line[64], *s, *e;
 351     char *extension, *plugin;
 352     int fd = open(config_file, O_RDONLY);
 353     if (fd < 0)
 354         return;
 355     /* config file is in the format
 356        <extension>,<plugin>,<icon code>
 357        ignore line if either of the first two are missing */
 358     while (read_line(fd, line, sizeof line) > 0)
 359     {
 360         if (filetype_count >= MAX_FILETYPES)
 361         {
 362             splash(HZ, ID2P(LANG_FILETYPES_FULL));
 363             break;
 364         }
 365         rm_whitespaces(line);
 366         /* get the extention */
 367         s = line;
 368         e = strchr(s, ',');
 369         if (!e)
 370             continue;
 371         *e = '\0';
 372         extension = s;
 373
 374         /* get the plugin */
 375         s = e+1;
 376         e = strchr(s, ',');
 377         if (!e)
 378             continue;
 379         *e = '\0';
 380         plugin = s;
 381
 382         /* ok, store this plugin/extension, check icon after */
 383         struct file_type *file_type = &filetypes[filetype_count];
 384         file_type->extension = filetypes_strdup(extension);
 385         file_type->plugin = filetypes_store_plugin(plugin, filetype_count);
 386         file_type->attr = highest_attr +1;
 387         file_type->icon = Icon_Questionmark;
 388         highest_attr++;
 389         /* get the icon */
 390         s = e+1;
 391         if (*s == '*')
 392             file_type->icon = atoi(s+1);
 393         else if (*s == '-')
 394             file_type->icon = Icon_NOICON;
 395         else if (*s >= '0' && *s <= '9')
 396             file_type->icon = Icon_Last_Themeable + atoi(s);
 397         filetype_count++;
 398     }
 399     close(fd);
 400 }
 401
 402 int filetype_get_attr(const char* file)
 403 {
 404     char *extension = strrchr(file, '.');
 405     int i;
 406     if (!extension)
 407         return 0;
 408     extension++;
 409     for (i=0; i<filetype_count; i++)
 410     {
 411         if (filetypes[i].extension &&
 412             !strcasecmp(extension, filetypes[i].extension))
 413             return (filetypes[i].attr<<8)&FILE_ATTR_MASK;
 414     }
 415     return 0;
 416 }
 417
 418 static int find_attr(int attr)
 419 {
 420     int i;
 421     /* skip the directory item */
 422     if ((attr & ATTR_DIRECTORY)==ATTR_DIRECTORY)
 423         return 0;
 424     for (i=1; i<filetype_count; i++)
 425     {
 426         if ((attr>>8) == filetypes[i].attr)
 427             return i;
 428     }
 429     return -1;
 430 }
 431
 432 #ifdef HAVE_LCD_COLOR
 433 int filetype_get_color(const char * name, int attr)
 434 {
 435     char *extension;
 436     int i;
 437     if ((attr & ATTR_DIRECTORY)==ATTR_DIRECTORY)
 438         return custom_colors[0];
 439     extension = strrchr(name, '.');
 440     if (!extension)
 441         return custom_colors[MAX_FILETYPES];
 442     extension++;
 443
 444     for (i=1; i<filetype_count; i++)
 445     {
 446         if (filetypes[i].extension &&
 447             !strcasecmp(extension, filetypes[i].extension))
 448             return custom_colors[i];
 449     }
 450     return custom_colors[MAX_FILETYPES];
 451 }
 452 #endif
 453
 454 int filetype_get_icon(int attr)
 455 {
 456     int index = find_attr(attr);
 457     if (index < 0)
 458         return Icon_NOICON;
 459     if (custom_icons_loaded)
 460         return custom_filetype_icons[index];
 461     return filetypes[index].icon;
 462 }
 463
 464 char* filetype_get_plugin(const struct entry* file)
 465 {
 466     static char plugin_name[MAX_PATH];
 467     int index = find_attr(file->attr);
 468     if (index < 0)
 469         return NULL;
 470     if (filetypes[index].plugin == NULL)
 471         return NULL;
 472     snprintf(plugin_name, MAX_PATH, "%s/%s.%s",
 473              PLUGIN_DIR, filetypes[index].plugin, ROCK_EXTENSION);
 474     return plugin_name;
 475 }
 476
 477 bool filetype_supported(int attr)
 478 {
 479     return find_attr(attr) >= 0;
 480 }
 481
 482 /**** Open With Screen ****/
 483 struct cb_data {
 484     const char *current_file;
 485 };
 486
 487 static enum themable_icons openwith_get_icon(int selected_item, void * data)
 488 {
 489     (void)data;
 490     return filetypes[viewers[selected_item]].icon;
 491 }
 492
 493 static const char* openwith_get_name(int selected_item, void * data,
 494                                      char * buffer, size_t buffer_len)
 495 {
 496     (void)data; (void)buffer; (void)buffer_len;
 497     const char *s = strrchr(filetypes[viewers[selected_item]].plugin, '/');
 498     if (s)
 499         return s+1;
 500     else return filetypes[viewers[selected_item]].plugin;
 501 }
 502
 503 static int openwith_action_callback(int action, struct gui_synclist *lists)
 504 {
 505     struct cb_data *info = (struct cb_data *)lists->data;
 506     int i;
 507     if (action == ACTION_STD_OK)
 508     {
 509         char plugin[MAX_PATH];
 510         i = viewers[gui_synclist_get_sel_pos(lists)];
 511         snprintf(plugin, MAX_PATH, "%s/%s.%s",
 512                     PLUGIN_DIR, filetypes[i].plugin, ROCK_EXTENSION);
 513         plugin_load(plugin, info->current_file);
 514         return ACTION_STD_CANCEL;
 515     }
 516     return action;
 517 }
 518
 519 int filetype_list_viewers(const char* current_file)
 520 {
 521     struct simplelist_info info;
 522     struct cb_data data = { current_file };
 523 #ifndef HAVE_LCD_BITMAP
 524     if (viewer_count == 0)
 525     {
 526         /* FIX: translation! */
 527         splash(HZ*2, "No viewers found");
 528         return PLUGIN_OK;
 529     }
 530 #endif
 531     simplelist_info_init(&info, str(LANG_ONPLAY_OPEN_WITH), viewer_count, &data);
 532     info.action_callback = openwith_action_callback;
 533     info.get_name = openwith_get_name;
 534     info.get_icon = global_settings.show_icons?openwith_get_icon:NULL;
 535     return simplelist_show_list(&info);
 536 }
 537
 538 int filetype_load_plugin(const char* plugin, char* file)
 539 {
 540     int i;
 541     char plugin_name[MAX_PATH];
 542     char *s;
 543
 544     for (i=0;i<filetype_count;i++)
 545     {
 546         if (filetypes[i].plugin)
 547         {
 548             s = strrchr(filetypes[i].plugin, '/');
 549             if (s)
 550             {
 551                 if (!strcmp(s+1, plugin))
 552                     break;
 553             }
 554             else if (!strcmp(filetypes[i].plugin, plugin))
 555                 break;
 556         }
 557     }
 558     if (i >= filetype_count)
 559         return PLUGIN_ERROR;
 560     snprintf(plugin_name, MAX_PATH, "%s/%s.%s",
 561              PLUGIN_DIR, filetypes[i].plugin, ROCK_EXTENSION);
 562     return plugin_load(plugin_name, file);
 563 }