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