apps/filetypes.c

   1 /***************************************************************************
   2  *             __________               __   ___.
   3  *   Open      \______   \ ____   ____ |  | _\_ |__   _______  ___
   4  *   Source     |       _//  _ \_/ ___\|  |/ /| __ \ /  _ \  \/  /
   5  *   Jukebox    |    |   (  <_> )  \___|    < | \_\ (  <_> > <  <
   6  *   Firmware   |____|_  /\____/ \___  >__|_ \|___  /\____/__/\_ \
   7  *
   8  * $Id$
   9  *
  10  * Copyright (C) 2004 Henrik Backe
  11  *
  12  * All files in this archive are subject to the GNU General Public License.
  13  * See the file COPYING in the source tree root for full license agreement.
  14  *
  15  * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY
  16  * KIND, either express or implied.
  17  *
  18  ****************************************************************************/
  19
  20 #include <stdio.h>
  21 #include <string.h>
  22 #include <stdlib.h>
  23 #include <stdbool.h>
  24
  25 #include "sprintf.h"
  26 #include "settings.h"
  27 #include "debug.h"
  28 #include "lang.h"
  29 #include "language.h"
  30 #include "kernel.h"
  31 #include "plugin.h"
  32 #include "filetypes.h"
  33 #include "screens.h"
  34 #include "icons.h"
  35 #include "dir.h"
  36 #include "file.h"
  37 #include "icons.h"
  38 #include "splash.h"
  39
  40 /* max plugin name size without extensions and path */
  41 #define MAX_PLUGIN_LENGTH 32
  42
  43 /* max filetypes (plugins & icons stored here) */
  44 #if CONFIG_CODEC == SWCODEC
  45 #define MAX_FILETYPES 64
  46 #else
  47 #define MAX_FILETYPES 32
  48 #endif
  49
  50 /* max exttypes (extensions stored here) */
  51 #if CONFIG_CODEC == SWCODEC
  52 /* Software codecs require more file extensions */
  53 #define MAX_EXTTYPES 64
  54 #else
  55 #define MAX_EXTTYPES 32
  56 #endif
  57
  58 /* string buffer length */
  59 #define STRING_BUFFER_SIZE 512
  60
  61 /* number of bytes for the binary icon */
  62 #define ICON_LENGTH 6
  63
  64 /* mask for dynamic filetype info in attribute */
  65 #define FILETYPES_MASK 0xFF00
  66
  67 /* filenames */
  68 #define ROCK_EXTENSION ".rock"
  69 #define VIEWERS_CONFIG ROCKBOX_DIR "/viewers.config"
  70 #define VIEWERS_DIR    ROCKBOX_DIR "/viewers"
  71
  72 /* global variables */
  73 static int    cnt_filetypes;
  74 static int    cnt_exttypes;
  75 static struct ext_type  exttypes [MAX_EXTTYPES];
  76 static struct file_type filetypes[MAX_FILETYPES];
  77 static int    first_soft_exttype;
  78 static int    first_soft_filetype;
  79 static char*  next_free_string;
  80 static char   plugin_name[sizeof(VIEWERS_DIR) + 7 + MAX_PLUGIN_LENGTH];
  81 static char   string_buffer[STRING_BUFFER_SIZE];
  82
  83 /* prototypes */
  84 #ifdef HAVE_LCD_BITMAP
  85 static char*  string2icon(const char*);
  86 static int    add_plugin(char*,char*);
  87 #else
  88 static int    add_plugin(char*);
  89 #endif
  90 static char*  get_string(const char*);
  91 static int    find_attr_index(int);
  92 static bool   read_config(const char*);
  93 static void   rm_whitespaces(char*);
  94 static void   scan_plugins(void);
  95
  96 /* initialize dynamic filetypes (called at boot from tree.c) */
  97 void filetype_init(void)
  98 {
  99     int cnt,i,ix;
 100     const struct filetype* ftypes;
 101
 102     memset(exttypes,0,sizeof(exttypes));
 103     memset(filetypes,0,sizeof(filetypes));
 104     next_free_string=string_buffer;
 105
 106 /* The special filetype folder must always be stored at index 0 */
 107 #ifdef HAVE_LCD_BITMAP
 108     if (!filetypes[0].icon)
 109         filetypes[0].icon = bitmap_icons_6x8[Icon_Folder];
 110 #else
 111     if (!filetypes[0].icon)
 112         filetypes[0].icon = Icon_Folder;
 113     for (i=1; i < MAX_FILETYPES; i++)
 114         filetypes[i].icon = -1;
 115 #endif
 116
 117     /* register hardcoded filetypes */
 118     tree_get_filetypes(&ftypes, &cnt);
 119     cnt_exttypes=0;
 120     cnt_filetypes=0;
 121
 122     for (i = 0; i < cnt ; i++)
 123     {
 124         ix = ((ftypes[i].tree_attr & FILETYPES_MASK) >> 8);
 125         if (ix < MAX_FILETYPES && i < MAX_EXTTYPES)
 126         {
 127 #ifdef HAVE_LCD_BITMAP
 128             if (filetypes[ix].icon == NULL)
 129                 filetypes[ix].icon=bitmap_icons_6x8[ftypes[i].icon];
 130 #else
 131             if (filetypes[ix].icon == -1)
 132                 filetypes[ix].icon=ftypes[i].icon;
 133 #endif
 134             if (ix > cnt_filetypes)
 135                 cnt_filetypes=ix;
 136             exttypes[cnt_exttypes].type=&filetypes[ix];
 137             exttypes[cnt_exttypes].extension=ftypes[i].extension;
 138             cnt_exttypes++;
 139         }
 140     }
 141     first_soft_exttype=cnt_exttypes;
 142     cnt_filetypes++;
 143     first_soft_filetype=cnt_filetypes;
 144
 145     /* register dynamic filetypes */
 146     read_config(VIEWERS_CONFIG);
 147     scan_plugins();
 148 }
 149
 150 /* get icon */
 151 #ifdef HAVE_LCD_BITMAP
 152 const unsigned char* filetype_get_icon(int attr)
 153 #else
 154 int   filetype_get_icon(int attr)
 155 #endif
 156 {
 157     int ix;
 158
 159     ix = find_attr_index(attr);
 160
 161     if (ix < 0)
 162     {
 163 #ifdef HAVE_LCD_BITMAP
 164         return NULL;
 165 #else
 166         return Icon_Unknown;
 167 #endif
 168     }
 169     else
 170     {
 171         return filetypes[ix].icon;
 172     }
 173 }
 174
 175 /* get plugin */
 176 char* filetype_get_plugin(const struct entry* file)
 177 {
 178     int ix;
 179
 180     ix=find_attr_index(file->attr);
 181
 182     if (ix < 0)
 183     {
 184         return NULL;
 185     }
 186
 187     if ((filetypes[ix].plugin == NULL) ||
 188         (strlen(filetypes[ix].plugin) > MAX_PLUGIN_LENGTH))
 189         return NULL;
 190
 191     snprintf(plugin_name, sizeof(plugin_name),
 192              "%s/%s.rock", ROCKBOX_DIR, filetypes[ix].plugin);
 193
 194     return plugin_name;
 195 }
 196
 197 /* check if filetype is supported */
 198 bool filetype_supported(int attr)
 199 {
 200     int ix;
 201
 202     ix=find_attr_index(attr);
 203
 204     /* hard filetypes and soft filetypes with plugins is supported */
 205     if (ix > 0)
 206         if (filetypes[ix].plugin || ix < first_soft_filetype)
 207             return true;
 208
 209     return false;
 210 }
 211
 212 /* get the "dynamic" attribute for an extension */
 213 int filetype_get_attr(const char* name)
 214 {
 215     int i;
 216     const char *cp = strrchr(name,'.');
 217
 218     if (!cp)  /* no extension? -> can't be a supported type */
 219         return 0;
 220     cp++;
 221
 222     for (i=0; i < cnt_exttypes; i++)
 223     {
 224         if (exttypes[i].extension)
 225         {
 226             if (!strcasecmp(cp,exttypes[i].extension))
 227             {
 228                 return ((((unsigned long)exttypes[i].type -
 229                           (unsigned long)&filetypes[0]) /
 230                          sizeof(struct file_type)) << 8);
 231             }
 232         }
 233     }
 234
 235     return 0;
 236 }
 237
 238 /* fill a menu list with viewers (used in onplay.c) */
 239 int filetype_load_menu(struct menu_item*  menu,int max_items)
 240 {
 241     int i;
 242     char *cp;
 243     int cnt=0;
 244
 245     for (i=0; i < cnt_filetypes; i++)
 246     {
 247         if (filetypes[i].plugin)
 248         {
 249             cp=strrchr(filetypes[i].plugin,'/');
 250             if (cp) cp++;
 251             else    cp=filetypes[i].plugin;
 252             menu[cnt].desc = (unsigned char *)cp;
 253             cnt++;
 254             if (cnt == max_items)
 255                 break;
 256         }
 257     }
 258     return cnt;
 259 }
 260
 261 /* start a plugin with an argument (called from onplay.c) */
 262 int filetype_load_plugin(const char* plugin, char* file)
 263 {
 264     snprintf(plugin_name,sizeof(plugin_name),"%s/%s.rock",
 265              VIEWERS_DIR,plugin);
 266     return plugin_load(plugin_name,file);
 267 }
 268
 269 /* get index to filetypes[] from the file attribute */
 270 static int find_attr_index(int attr)
 271 {
 272     int ix;
 273     ix = ((attr & FILETYPES_MASK) >> 8);
 274
 275     if ((attr & ATTR_DIRECTORY)==ATTR_DIRECTORY)
 276     {
 277         ix=0;
 278     }
 279     else
 280     {
 281         if (ix==0)
 282             ix=-1;
 283         if (ix > cnt_filetypes)
 284             ix=-1;
 285         else
 286             if ((filetypes[ix].plugin == NULL) &&
 287 #ifdef HAVE_LCD_BITMAP
 288                 (filetypes[ix].icon == NULL)
 289 #else
 290                 (filetypes[ix].icon == -1)
 291 #endif
 292                 )
 293                 ix=-1;
 294     }
 295
 296     return ix;
 297 }
 298
 299 /* scan the plugin directory and register filetypes */
 300 static void scan_plugins(void)
 301 {
 302     DIR *dir;
 303     struct dirent *entry;
 304     char* cp;
 305     char* dot;
 306     char* dash;
 307     int   ix;
 308     int   i;
 309     bool  found;
 310
 311     dir = opendir(VIEWERS_DIR);
 312     if(!dir)
 313         return;
 314
 315     while (true)
 316     {
 317         /* exttypes[] full, bail out */
 318         if (cnt_exttypes >= MAX_EXTTYPES)
 319         {
 320             gui_syncsplash(HZ, true, str(LANG_FILETYPES_EXTENSION_FULL));
 321             break;
 322         }
 323
 324         /* filetypes[] full, bail out */
 325         if (cnt_filetypes >= MAX_FILETYPES)
 326         {
 327             gui_syncsplash(HZ, true, str(LANG_FILETYPES_FULL));
 328             break;
 329         }
 330
 331         entry = readdir(dir);
 332
 333         if (!entry)
 334             break;
 335
 336         /* skip directories */
 337         if ((entry->attribute & ATTR_DIRECTORY))
 338             continue;
 339
 340         /* Skip FAT volume ID */
 341         if (entry->attribute & ATTR_VOLUME_ID)
 342             continue;
 343
 344         /* filter out dotfiles and hidden files */
 345         if ((entry->d_name[0]=='.') ||
 346             (entry->attribute & ATTR_HIDDEN)) {
 347             continue;
 348         }
 349
 350         /* filter out non rock files */
 351         if (strcasecmp((char *)&entry->d_name[strlen((char *)entry->d_name) -
 352                                               sizeof(ROCK_EXTENSION) + 1],
 353                        ROCK_EXTENSION)) {
 354             continue;
 355         }
 356
 357         /* filter out to long filenames */
 358         if (strlen((char *)entry->d_name) > MAX_PLUGIN_LENGTH + 5)
 359         {
 360             gui_syncsplash(HZ, true, str(LANG_FILETYPES_PLUGIN_NAME_LONG));
 361             continue;
 362         }
 363
 364         dot=strrchr((char *)entry->d_name,'.');
 365         *dot='\0';
 366         dash=strchr((char *)entry->d_name,'-');
 367
 368         /* add plugin and extension */
 369         if (dash)
 370         {
 371             *dash='\0';
 372             ix=(filetype_get_attr((char *)entry->d_name) >> 8);
 373             if (!ix)
 374             {
 375                 cp=get_string((char *)entry->d_name);
 376                 if (cp)
 377                 {
 378                     exttypes[cnt_exttypes].extension=cp;
 379                     exttypes[cnt_exttypes].type=&filetypes[cnt_filetypes];
 380 #ifdef HAVE_LCD_BITMAP
 381                     exttypes[cnt_exttypes].type->icon = bitmap_icons_6x8[Icon_Plugin];
 382 #else
 383                     exttypes[cnt_exttypes].type->icon = Icon_Plugin;
 384 #endif
 385                     cnt_exttypes++;
 386
 387                     *dash='-';
 388                     cp=get_string((char *)entry->d_name);
 389                     if (cp)
 390                     {
 391                         filetypes[cnt_filetypes].plugin=cp;
 392                         cnt_filetypes++;
 393                     }
 394                     else
 395                         break;
 396                 }
 397                 else
 398                     break;
 399             }
 400             else
 401             {
 402                 *dash='-';
 403                 if (!filetypes[ix].plugin)
 404                 {
 405                     cp=get_string((char *)entry->d_name);
 406                     if (cp)
 407                     {
 408                         filetypes[cnt_filetypes].plugin=cp;
 409                         cnt_filetypes++;
 410                     }
 411                     else
 412                         break;
 413                 }
 414             }
 415             *dash='-';
 416         }
 417         /* add plugin only */
 418         else
 419         {
 420             found=false;
 421             for (i = first_soft_filetype; i < cnt_filetypes; i++)
 422             {
 423                 if (filetypes[i].plugin)
 424                     if (!strcasecmp(filetypes[i].plugin, (char *)entry->d_name))
 425                     {
 426                         found=true;
 427                         break;
 428                     }
 429             }
 430
 431             if (!found)
 432             {
 433                 cp=get_string((char *)entry->d_name);
 434                 if (cp)
 435                 {
 436                     filetypes[cnt_filetypes].plugin=cp;
 437                     filetypes[cnt_filetypes].no_extension=true;
 438                     cnt_filetypes++;
 439                 }
 440                 else
 441                     break;
 442             }
 443         }
 444         *dot='.';
 445     }
 446     closedir(dir);
 447 }
 448
 449 #ifdef HAVE_LCD_BITMAP
 450 static int add_plugin(char *plugin, char *icon)
 451 #else
 452 static int add_plugin(char *plugin)
 453 #endif
 454 {
 455     char *cp;
 456     int i;
 457
 458     if (!plugin)
 459         return 0;
 460
 461 #if 0
 462     /* starting now, Oct 2005, the plugins are given without extension in the
 463        viewers.config file */
 464     cp=strrchr(plugin, '.');
 465     if (cp)
 466         *cp='\0';
 467 #endif
 468
 469     for (i=first_soft_filetype; i < cnt_filetypes; i++)
 470     {
 471         if (filetypes[i].plugin)
 472         {
 473             if (!strcasecmp(plugin, filetypes[i].plugin))
 474             {
 475 #ifdef HAVE_LCD_BITMAP
 476                 if (filetypes[i].icon == NULL && icon)
 477                 {
 478                     cp = string2icon(icon);
 479                     if (cp)
 480                         filetypes[cnt_filetypes].icon = (unsigned char *)cp;
 481                     else
 482                         return 0;
 483                 }
 484 #endif
 485                 return i;
 486             }
 487         }
 488     }
 489
 490     /* new plugin */
 491     cp = get_string(plugin);
 492     if (cp)
 493     {
 494         filetypes[cnt_filetypes].plugin = cp;
 495 #ifdef HAVE_LCD_BITMAP
 496         /* add icon */
 497         if (icon)
 498         {
 499             cp = string2icon(icon);
 500             if (cp)
 501                 filetypes[cnt_filetypes].icon = (unsigned char *)cp;
 502             else
 503                 return 0;
 504         }
 505 #endif
 506     }
 507     else
 508     {
 509         return 0;
 510     }
 511
 512     cnt_filetypes++;
 513     return cnt_filetypes - 1;
 514 }
 515
 516 /* read config file (or cahe file) */
 517 bool read_config(const char* file)
 518 {
 519     enum {extension,
 520           plugin,
 521 #ifdef HAVE_LCD_BITMAP
 522           icon,
 523 #endif
 524           last};
 525
 526     int   i,ix;
 527     int   fd;
 528     char* end;
 529     char* cp;
 530     char* str[last];
 531     char   buf[80];
 532
 533     fd = open(file, O_RDONLY);
 534     if (fd < 0)
 535         return false;
 536
 537     while (read_line(fd, buf, sizeof(buf)))
 538     {
 539         if (cnt_exttypes >= MAX_EXTTYPES)
 540         {
 541             gui_syncsplash(HZ, true, str(LANG_FILETYPES_EXTENSION_FULL));
 542             break;
 543         }
 544
 545         if (cnt_filetypes >= MAX_FILETYPES)
 546         {
 547             gui_syncsplash(HZ, true, str(LANG_FILETYPES_FULL));
 548             break;
 549         }
 550
 551         /* parse buffer */
 552         rm_whitespaces(buf);
 553
 554         if (strlen(buf) == 0)
 555             continue;
 556
 557         if (buf[0] == '#')
 558             continue;
 559
 560         memset(str,0,sizeof(str));
 561         i=0;
 562         cp=buf;
 563         while (*cp==',') {
 564             cp++;
 565             i++;
 566         }
 567         str[i] = strtok_r(cp, ",", &end);
 568         i++;
 569
 570         while (end && i < last)
 571         {
 572             if (end)
 573             {
 574                 cp=end;
 575                 while (*cp==',') {
 576                     cp++;
 577                     i++;
 578                 }
 579             }
 580             str[i] = strtok_r(NULL, ",", &end);
 581             if (str[i])
 582                 if (!strlen(str[i]))
 583                     str[i]=NULL;
 584             i++;
 585         }
 586
 587         /* bail out if no icon and no plugin */
 588         if (!str[plugin]
 589 #ifdef HAVE_LCD_BITMAP
 590             && !str[icon]
 591 #endif
 592            )
 593             continue;
 594
 595         /* bail out if no plugin and icon is incorrect*/
 596         if (!str[plugin]
 597 #ifdef HAVE_LCD_BITMAP
 598             && strlen(str[icon]) != ICON_LENGTH*2
 599 #endif
 600            )
 601             continue;
 602
 603         /* bail out if no icon and no plugin and no extension*/
 604         if (!str[plugin] &&
 605 #ifdef HAVE_LCD_BITMAP
 606             !str[icon] &&
 607 #endif
 608             !str[extension])
 609             continue;
 610
 611         /* bail out if we are not able to start plugin from onplay.c ?*/
 612         if (str[plugin])
 613         {
 614             if (strlen(str[plugin]) > MAX_PLUGIN_LENGTH)
 615             {
 616                 gui_syncsplash(HZ, true, str(LANG_FILETYPES_PLUGIN_NAME_LONG));
 617                 str[plugin] = NULL;
 618                 continue;
 619             }
 620         }
 621
 622         ix=0;
 623         /* if extension already exist don't add a new one */
 624         for (i=0; i < cnt_exttypes; i++)
 625         {
 626             if (!strcasecmp(str[extension],exttypes[i].extension))
 627             {
 628 #ifdef HAVE_LCD_BITMAP
 629                 ix=add_plugin(str[plugin],NULL);
 630                 if (ix)
 631                 {
 632                     if (str[icon] && filetypes[ix].icon == NULL)
 633                     {
 634                         if (exttypes[i].type->icon == NULL)
 635                         {
 636                             cp = string2icon(str[icon]);
 637                             if (cp)
 638                                 exttypes[i].type->icon = (unsigned char *)cp;
 639                         }
 640                     }
 641                 }
 642 #else
 643                 ix=add_plugin(str[plugin]);
 644 #endif
 645                 if (exttypes[i].type == NULL)
 646                 {
 647                     exttypes[i].type = &filetypes[ix];
 648                 }
 649                 break;
 650             }
 651         }
 652         if (ix)
 653             continue;
 654
 655         /* add extension */
 656         if (str[extension])
 657         {
 658 #ifdef HAVE_LCD_BITMAP
 659             ix=add_plugin(str[plugin],str[icon]);
 660 #else
 661             ix=add_plugin(str[plugin]);
 662 #endif
 663             if (ix)
 664             {
 665                 cp=get_string(str[extension]);
 666                 if (cp)
 667                 {
 668                     exttypes[cnt_exttypes].extension = cp;
 669
 670                     exttypes[cnt_exttypes].type = &filetypes[ix];
 671                     cnt_exttypes++;
 672                     filetypes[i].no_extension=false;
 673                 }
 674                 else
 675                 {
 676                     break;
 677                 }
 678             }
 679             else
 680             {
 681                 break;
 682             }
 683         }
 684         else
 685         {
 686 #ifdef HAVE_LCD_BITMAP
 687             ix=add_plugin(str[plugin],str[icon]);
 688 #else
 689             ix=add_plugin(str[plugin]);
 690 #endif
 691             filetypes[ix].no_extension=true;
 692             if (!i)
 693                 break;
 694         }
 695     }
 696     close(fd);
 697
 698     return true;
 699 }
 700
 701 #ifdef HAVE_LCD_BITMAP
 702 /* convert an ascii hexadecimal icon to a binary icon */
 703 static char* string2icon(const char* str)
 704 {
 705     char tmp[ICON_LENGTH*2];
 706     char *cp;
 707     int i;
 708
 709     if (strlen(str)!=ICON_LENGTH*2)
 710         return NULL;
 711
 712     if ((sizeof(string_buffer) +
 713          (unsigned long) string_buffer -
 714          (unsigned long) next_free_string) < ICON_LENGTH)
 715     {
 716         gui_syncsplash(HZ, true, str(LANG_FILETYPES_STRING_BUFFER_EMPTY));
 717         return NULL;
 718     }
 719
 720     for (i=0; i<12; i++)
 721     {
 722         if (str[i] >= '0' && str[i] <= '9')
 723         {
 724             tmp[i]=str[i]-'0';
 725             continue;
 726         }
 727
 728         if (str[i] >= 'a' && str[i] <= 'f')
 729         {
 730             tmp[i]=str[i]-'a'+10;
 731             continue;
 732         }
 733
 734         if (str[i] >= 'A' && str[i] <= 'F')
 735         {
 736             tmp[i]=str[i]-'A'+10;
 737             continue;
 738         }
 739
 740         return NULL;
 741     }
 742
 743     cp=next_free_string;
 744     for (i = 0; i < ICON_LENGTH; i++)
 745         cp[i]=((tmp[i*2]<<4) | tmp[i*2+1]);
 746
 747     next_free_string=&next_free_string[ICON_LENGTH];
 748     return cp;
 749 }
 750 #endif
 751
 752 /* get string from buffer */
 753 static char* get_string(const char* str)
 754 {
 755     unsigned int l=strlen(str)+1;
 756     char* cp;
 757
 758     if (!str)
 759         return NULL;
 760
 761     if (l <= (sizeof(string_buffer) +
 762              (unsigned long) string_buffer -
 763              (unsigned long) next_free_string))
 764     {
 765         strcpy(next_free_string, str);
 766         cp=next_free_string;
 767         next_free_string=&next_free_string[l];
 768         return cp;
 769     }
 770     else
 771     {
 772         gui_syncsplash(HZ, true, str(LANG_FILETYPES_STRING_BUFFER_EMPTY));
 773         return NULL;
 774     }
 775 }
 776
 777 /* remove all white spaces from string */
 778 static void rm_whitespaces(char* str)
 779 {
 780     char *cp, *free;
 781
 782     cp=str;
 783     free=cp;
 784
 785     while (cp < &str[strlen(str)])
 786     {
 787         switch (*cp)
 788         {
 789             case ' '  :
 790             case '\t' :
 791             case '\r' :
 792                 break;
 793
 794             default:
 795                 *free=*cp;
 796                 free++;
 797                 break;
 798         }
 799         cp++;
 800     }
 801
 802     *free='\0';
 803 }