apps/plugins/properties.c

   1 /***************************************************************************
   2  *             __________               __   ___.
   3  *   Open      \______   \ ____   ____ |  | _\_ |__   _______  ___
   4  *   Source     |       _//  _ \_/ ___\|  |/ /| __ \ /  _ \  \/  /
   5  *   Jukebox    |    |   (  <_> )  \___|    < | \_\ (  <_> > <  <
   6  *   Firmware   |____|_  /\____/ \___  >__|_ \|___  /\____/__/\_ \
   7  *                     \/            \/     \/    \/            \/
   8  * $Id$
   9  *
  10  * Copyright (C) 2006 Peter D'Hoye
  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 #include "plugin.h"
  22
  23 PLUGIN_HEADER
  24
  25 bool its_a_dir = false;
  26
  27 char str_filename[MAX_PATH];
  28 char str_dirname[MAX_PATH];
  29 char str_size[64];
  30 char str_dircount[64];
  31 char str_filecount[64];
  32 char str_date[64];
  33 char str_time[64];
  34
  35 char str_title[MAX_PATH];
  36 char str_artist[MAX_PATH];
  37 char str_album[MAX_PATH];
  38 char str_duration[32];
  39
  40 int num_properties;
  41
  42 static char* filesize2string(long long size, char* pstr, int len)
  43 {
  44     /* margin set at 10K boundary: 10239 B +1 => 10 KB
  45        routine below is 200 bytes smaller than cascaded if/else :)
  46        not using build-in function because of huge values (long long) */
  47     const char* kgb[4] = { "B", "KB", "MB", "GB" };
  48     int i = 0;
  49     while(true)
  50     {
  51         if((size < 10240) || (i > 2))
  52         {
  53             /* depends on the order in the above array */
  54             rb->snprintf(pstr, len, "%ld %s", (long)size, kgb[i]);
  55             break;
  56         }
  57         size >>= 10; /* div by 1024 */
  58         i++;
  59     }
  60     return pstr;
  61 }
  62
  63 static bool file_properties(char* selected_file)
  64 {
  65     bool found = false;
  66     char tstr[MAX_PATH];
  67     DIR* dir;
  68     struct dirent* entry;
  69     struct mp3entry id3;
  70
  71     char* ptr = rb->strrchr(selected_file, '/') + 1;
  72     int dirlen = (ptr - selected_file);
  73     rb->strlcpy(tstr, selected_file, dirlen + 1);
  74
  75     dir = rb->opendir(tstr);
  76     if (dir)
  77     {
  78         while(0 != (entry = rb->readdir(dir)))
  79         {
  80             if(!rb->strcmp(entry->d_name, selected_file+dirlen))
  81             {
  82                 rb->snprintf(str_dirname, sizeof str_dirname, "Path: %s",
  83                              tstr);
  84                 rb->snprintf(str_filename, sizeof str_filename, "Name: %s",
  85                              selected_file+dirlen);
  86                 rb->snprintf(str_size, sizeof str_size, "Size: %s",
  87                              filesize2string(entry->size, tstr, sizeof tstr));
  88                 rb->snprintf(str_date, sizeof str_date, "Date: %04d/%02d/%02d",
  89                     ((entry->wrtdate >> 9 ) & 0x7F) + 1980, /* year    */
  90                     ((entry->wrtdate >> 5 ) & 0x0F),        /* month   */
  91                     ((entry->wrtdate      ) & 0x1F));       /* day     */
  92                 rb->snprintf(str_time, sizeof str_time, "Time: %02d:%02d",
  93                     ((entry->wrttime >> 11) & 0x1F),        /* hour    */
  94                     ((entry->wrttime >> 5 ) & 0x3F));       /* minutes */
  95
  96                 num_properties = 5;
  97
  98 #if (CONFIG_CODEC == SWCODEC)
  99                 int fd = rb->open(selected_file, O_RDONLY);
 100                 if (fd >= 0 &&
 101                     rb->get_metadata(&id3, fd, selected_file))
 102 #else
 103                 if (!rb->mp3info(&id3, selected_file))
 104 #endif
 105                 {
 106                     long dur = id3.length / 1000;           /* seconds */
 107                     rb->snprintf(str_artist, sizeof str_artist,
 108                                  "Artist: %s", id3.artist ? id3.artist : "");
 109                     rb->snprintf(str_title, sizeof str_title,
 110                                  "Title: %s", id3.title ? id3.title : "");
 111                     rb->snprintf(str_album, sizeof str_album,
 112                                  "Album: %s", id3.album ? id3.album : "");
 113                     num_properties += 3;
 114
 115                     if (dur > 0)
 116                     {
 117                         if (dur < 3600)
 118                             rb->snprintf(str_duration, sizeof str_duration,
 119                                          "Duration: %d:%02d", (int)(dur / 60),
 120                                          (int)(dur % 60));
 121                         else
 122                             rb->snprintf(str_duration, sizeof str_duration,
 123                                          "Duration: %d:%02d:%02d",
 124                                          (int)(dur / 3600),
 125                                          (int)(dur % 3600 / 60),
 126                                          (int)(dur % 60));
 127                         num_properties++;
 128                     }
 129                 }
 130 #if (CONFIG_CODEC == SWCODEC)
 131                 rb->close(fd);
 132 #endif
 133                 found = true;
 134                 break;
 135             }
 136         }
 137         rb->closedir(dir);
 138     }
 139     return found;
 140 }
 141
 142 typedef struct {
 143     char dirname[MAX_PATH];
 144     int len;
 145     unsigned int dc;
 146     unsigned int fc;
 147     long long bc;
 148     char tstr[64];
 149     char tstr2[64];
 150 } DPS;
 151
 152 static bool _dir_properties(DPS* dps)
 153 {
 154     /* recursively scan directories in search of files
 155        and informs the user of the progress */
 156     bool result;
 157     int dirlen;
 158     DIR* dir;
 159     struct dirent* entry;
 160
 161     result = true;
 162     dirlen = rb->strlen(dps->dirname);
 163     dir = rb->opendir(dps->dirname);
 164     if (!dir)
 165         return false; /* open error */
 166
 167     /* walk through the directory content */
 168     while(result && (0 != (entry = rb->readdir(dir))))
 169     {
 170         /* append name to current directory */
 171         rb->snprintf(dps->dirname+dirlen, dps->len-dirlen, "/%s",
 172                      entry->d_name);
 173
 174         if (entry->attribute & ATTR_DIRECTORY)
 175         {
 176             if (!rb->strcmp((char *)entry->d_name, ".") ||
 177                 !rb->strcmp((char *)entry->d_name, ".."))
 178                 continue; /* skip these */
 179
 180             dps->dc++; /* new directory */
 181             rb->lcd_clear_display();
 182             rb->lcd_puts(0,0,"SCANNING...");
 183             rb->lcd_puts(0,1,dps->dirname);
 184             rb->lcd_puts(0,2,entry->d_name);
 185             rb->snprintf(dps->tstr, 64, "Directories: %d", dps->dc);
 186             rb->lcd_puts(0,3,dps->tstr);
 187             rb->snprintf(dps->tstr, 64, "Files: %d", dps->fc);
 188             rb->lcd_puts(0,4,dps->tstr);
 189             rb->snprintf(dps->tstr, 64, "Size: %s",
 190                 filesize2string(dps->bc, dps->tstr2, 64));
 191             rb->lcd_puts(0,5,dps->tstr);
 192             rb->lcd_update();
 193
 194              /* recursion */
 195             result = _dir_properties(dps);
 196         }
 197         else
 198         {
 199             dps->fc++; /* new file */
 200             dps->bc += entry->size;
 201         }
 202         if(ACTION_STD_CANCEL == rb->get_action(CONTEXT_STD,TIMEOUT_NOBLOCK))
 203             result = false;
 204         rb->yield();
 205     }
 206     rb->closedir(dir);
 207     return result;
 208 }
 209
 210 static bool dir_properties(char* selected_file)
 211 {
 212     DPS dps;
 213     char tstr[64];
 214     rb->strlcpy(dps.dirname, selected_file, MAX_PATH);
 215     dps.len = MAX_PATH;
 216     dps.dc = 0;
 217     dps.fc = 0;
 218     dps.bc = 0;
 219     if(false == _dir_properties(&dps))
 220         return false;
 221
 222     rb->strlcpy(str_dirname, selected_file, MAX_PATH);
 223     rb->snprintf(str_dircount, sizeof str_dircount, "Subdirs: %d", dps.dc);
 224     rb->snprintf(str_filecount, sizeof str_filecount, "Files: %d", dps.fc);
 225     rb->snprintf(str_size, sizeof str_size, "Size: %s",
 226                  filesize2string(dps.bc, tstr, sizeof tstr));
 227     num_properties = 4;
 228     return true;
 229 }
 230
 231 static const char * get_props(int selected_item, void* data,
 232                               char *buffer, size_t buffer_len)
 233 {
 234     (void)data;
 235
 236     switch(selected_item)
 237     {
 238         case 0:
 239             rb->strlcpy(buffer, str_dirname, buffer_len);
 240             break;
 241         case 1:
 242             rb->strlcpy(buffer, its_a_dir ? str_dircount : str_filename,
 243                         buffer_len);
 244             break;
 245         case 2:
 246             rb->strlcpy(buffer, its_a_dir ? str_filecount : str_size, buffer_len);
 247             break;
 248         case 3:
 249             rb->strlcpy(buffer, its_a_dir ? str_size : str_date, buffer_len);
 250             break;
 251         case 4:
 252             rb->strlcpy(buffer, its_a_dir ? "" : str_time, buffer_len);
 253             break;
 254         case 5:
 255             rb->strlcpy(buffer, its_a_dir ? "" : str_artist, buffer_len);
 256             break;
 257         case 6:
 258             rb->strlcpy(buffer, its_a_dir ? "" : str_title, buffer_len);
 259             break;
 260         case 7:
 261             rb->strlcpy(buffer, its_a_dir ? "" : str_album, buffer_len);
 262             break;
 263         case 8:
 264             rb->strlcpy(buffer, its_a_dir ? "" : str_duration, buffer_len);
 265             break;
 266         default:
 267             return "ERROR";
 268     }
 269     return buffer;
 270 }
 271
 272 enum plugin_status plugin_start(const void* parameter)
 273 {
 274     struct gui_synclist properties_lists;
 275     int button;
 276     bool quit = false;
 277     char file[MAX_PATH];
 278     if(!parameter) return PLUGIN_ERROR;
 279     rb->strcpy(file, (const char *) parameter);
 280
 281     /* determine if it's a file or a directory */
 282     bool found = false;
 283     DIR* dir;
 284     struct dirent* entry;
 285     char* ptr = rb->strrchr(file, '/') + 1;
 286     int dirlen = (ptr - file);
 287     rb->strlcpy(str_dirname, file, dirlen + 1);
 288
 289     dir = rb->opendir(str_dirname);
 290     if (dir)
 291     {
 292         while(0 != (entry = rb->readdir(dir)))
 293         {
 294             if(!rb->strcmp(entry->d_name, file+dirlen))
 295             {
 296                 its_a_dir = entry->attribute & ATTR_DIRECTORY ? true : false;
 297                 found = true;
 298                 break;
 299             }
 300         }
 301         rb->closedir(dir);
 302     }
 303     /* now we know if it's a file or a dir or maybe something failed */
 304
 305     if(!found)
 306     {
 307         /* weird: we couldn't find the entry. This Should Never Happen (TM) */
 308         rb->splashf(0, "File/Dir not found: %s", file);
 309         rb->action_userabort(TIMEOUT_BLOCK);
 310         return PLUGIN_OK;
 311     }
 312
 313     /* get the info depending on its_a_dir */
 314     if(!(its_a_dir ? dir_properties(file) : file_properties(file)))
 315     {
 316         /* something went wrong (to do: tell user what it was (nesting,...) */
 317         rb->splash(0, "Failed to gather information");
 318         rb->action_userabort(TIMEOUT_BLOCK);
 319         return PLUGIN_OK;
 320     }
 321
 322     rb->gui_synclist_init(&properties_lists, &get_props, file, false, 1, NULL);
 323     rb->gui_synclist_set_title(&properties_lists, its_a_dir ?
 324                                                   "Directory properties" :
 325                                                   "File properties", NOICON);
 326     rb->gui_synclist_set_icon_callback(&properties_lists, NULL);
 327     rb->gui_synclist_set_nb_items(&properties_lists, num_properties);
 328     rb->gui_synclist_limit_scroll(&properties_lists, true);
 329     rb->gui_synclist_select_item(&properties_lists, 0);
 330     rb->gui_synclist_draw(&properties_lists);
 331
 332     while(!quit)
 333     {
 334         button = rb->get_action(CONTEXT_LIST,TIMEOUT_BLOCK);
 335         if (rb->gui_synclist_do_button(&properties_lists,&button,LIST_WRAP_ON))
 336             continue;
 337         switch(button)
 338         {
 339             case ACTION_STD_CANCEL:
 340                 quit = true;
 341                 break;
 342             default:
 343                 if (rb->default_event_handler(button) == SYS_USB_CONNECTED)
 344                     return PLUGIN_USB_CONNECTED;
 345         }
 346     }
 347
 348     return PLUGIN_OK;
 349 }