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