apps/playlist_catalog.c

   1 /***************************************************************************
   2  *             __________               __   ___.
   3  *   Open      \______   \ ____   ____ |  | _\_ |__   _______  ___
   4  *   Source     |       _//  _ \_/ ___\|  |/ /| __ \ /  _ \  \/  /
   5  *   Jukebox    |    |   (  <_> )  \___|    < | \_\ (  <_> > <  <
   6  *   Firmware   |____|_  /\____/ \___  >__|_ \|___  /\____/__/\_ \
   7  *                     \/            \/     \/    \/            \/
   8  * $Id$
   9  *
  10  * Copyright (C) 2006 Sebastian Henriksen, Hardeep Sidhu
  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 <stdbool.h>
  21 #include <stdio.h>
  22 #include <stdlib.h>
  23 #include <string.h>
  24 #include "action.h"
  25 #include "dir.h"
  26 #include "file.h"
  27 #include "filetree.h"
  28 #include "kernel.h"
  29 #include "keyboard.h"
  30 #include "lang.h"
  31 #include "list.h"
  32 #include "misc.h"
  33 #include "onplay.h"
  34 #include "playlist.h"
  35 #include "settings.h"
  36 #include "splash.h"
  37 #include "sprintf.h"
  38 #include "tree.h"
  39 #include "yesno.h"
  40 #include "filetypes.h"
  41 #include "debug.h"
  42 #include "playlist_catalog.h"
  43
  44 #define MAX_PLAYLISTS 400
  45 #define PLAYLIST_DISPLAY_COUNT 10
  46
  47 /* Use for recursive directory search */
  48 struct add_track_context {
  49     int fd;
  50     int count;
  51 };
  52
  53 /* keep track of most recently used playlist */
  54 static char most_recent_playlist[MAX_PATH];
  55
  56 /* directory where our playlists our stored */
  57 static char playlist_dir[MAX_PATH];
  58 static int  playlist_dir_length;
  59 static bool playlist_dir_exists = false;
  60
  61 /* Retrieve playlist directory from config file and verify it exists */
  62 static int initialize_catalog(void)
  63 {
  64     static bool initialized = false;
  65
  66     if (!initialized)
  67     {
  68         bool default_dir = true;
  69
  70         /* directory config is of the format: "dir: /path/to/dir" */
  71         if (global_settings.playlist_catalog_dir[0])
  72         {
  73             strcpy(playlist_dir, global_settings.playlist_catalog_dir);
  74             default_dir = false;
  75         }
  76
  77         /* fall back to default directory if no or invalid config */
  78         if (default_dir)
  79             strncpy(playlist_dir, PLAYLIST_CATALOG_DEFAULT_DIR,
  80                 sizeof(playlist_dir));
  81
  82         playlist_dir_length = strlen(playlist_dir);
  83
  84         if (dir_exists(playlist_dir))
  85         {
  86             playlist_dir_exists = true;
  87             memset(most_recent_playlist, 0, sizeof(most_recent_playlist));
  88             initialized = true;
  89         }
  90     }
  91
  92     if (!playlist_dir_exists)
  93     {
  94         if (mkdir(playlist_dir) < 0) {
  95             gui_syncsplash(HZ*2, str(LANG_CATALOG_NO_DIRECTORY),
  96                 playlist_dir);
  97             return -1;
  98         }
  99         else {
 100             playlist_dir_exists = true;
 101             memset(most_recent_playlist, 0, sizeof(most_recent_playlist));
 102             initialized = true;
 103         }
 104     }
 105
 106     return 0;
 107 }
 108 /* Use the filetree functions to retrieve the list of playlists in the
 109    directory */
 110 static int create_playlist_list(char** playlists, int num_items,
 111                                 int* num_playlists)
 112 {
 113     int result = -1;
 114     int num_files = 0;
 115     int index = 0;
 116     int i;
 117     bool most_recent = false;
 118     struct entry *files;
 119     struct tree_context* tc = tree_get_context();
 120     int dirfilter = *(tc->dirfilter);
 121
 122     *num_playlists = 0;
 123
 124     /* use the tree browser dircache to load only playlists */
 125     *(tc->dirfilter) = SHOW_PLAYLIST;
 126
 127     if (ft_load(tc, playlist_dir) < 0)
 128     {
 129         gui_syncsplash(HZ*2, str(LANG_CATALOG_NO_DIRECTORY),
 130             playlist_dir);
 131         goto exit;
 132     }
 133
 134     files = (struct entry*) tc->dircache;
 135     num_files = tc->filesindir;
 136
 137     /* we've overwritten the dircache so tree browser will need to be
 138        reloaded */
 139     reload_directory();
 140
 141     /* if it exists, most recent playlist will always be index 0 */
 142     if (most_recent_playlist[0] != '\0')
 143     {
 144         index = 1;
 145         most_recent = true;
 146     }
 147
 148     for (i=0; i<num_files && index<num_items; i++)
 149     {
 150         if (files[i].attr & FILE_ATTR_M3U)
 151         {
 152             if (most_recent && !strncmp(files[i].name, most_recent_playlist,
 153                 sizeof(most_recent_playlist)))
 154             {
 155                 playlists[0] = files[i].name;
 156                 most_recent = false;
 157             }
 158             else
 159             {
 160                 playlists[index] = files[i].name;
 161                 index++;
 162             }
 163         }
 164     }
 165
 166     *num_playlists = index;
 167
 168     /* we couldn't find the most recent playlist, shift all playlists up */
 169     if (most_recent)
 170     {
 171         for (i=0; i<index-1; i++)
 172             playlists[i] = playlists[i+1];
 173
 174         (*num_playlists)--;
 175
 176         most_recent_playlist[0] = '\0';
 177     }
 178
 179     result = 0;
 180
 181 exit:
 182     *(tc->dirfilter) = dirfilter;
 183     return result;
 184 }
 185
 186 /* Callback for gui_synclist */
 187 static char* playlist_callback_name(int selected_item, void* data,
 188                                     char* buffer, size_t buffer_len)
 189 {
 190     char** playlists = (char**) data;
 191
 192     strncpy(buffer, playlists[selected_item], buffer_len);
 193
 194     if (buffer[0] != '.' && !(global_settings.show_filename_ext == 1
 195         || (global_settings.show_filename_ext == 3
 196             && global_settings.dirfilter == 0)))
 197     {
 198         char* dot = strrchr(buffer, '.');
 199
 200         if (dot != NULL)
 201         {
 202             *dot = '\0';
 203         }
 204     }
 205
 206     return buffer;
 207 }
 208
 209 /* Display all playlists in catalog.  Selected "playlist" is returned.
 210    If "view" mode is set then we're not adding anything into playlist. */
 211 static int display_playlists(char* playlist, bool view)
 212 {
 213     int result = -1;
 214     int num_playlists = 0;
 215     bool exit = false;
 216     char temp_buf[MAX_PATH];
 217     char* playlists[MAX_PLAYLISTS];
 218     struct gui_synclist playlist_lists;
 219
 220     if (create_playlist_list(playlists, sizeof(playlists),
 221             &num_playlists) != 0)
 222         return -1;
 223
 224     if (num_playlists <= 0)
 225     {
 226         gui_syncsplash(HZ*2, str(LANG_CATALOG_NO_PLAYLISTS));
 227         return -1;
 228     }
 229
 230     if (!playlist)
 231         playlist = temp_buf;
 232
 233     gui_synclist_init(&playlist_lists, playlist_callback_name, playlists,
 234                        false, 1, NULL);
 235     gui_synclist_set_nb_items(&playlist_lists, num_playlists);
 236     gui_synclist_draw(&playlist_lists);
 237
 238     while (!exit)
 239     {
 240         int button = get_action(CONTEXT_LIST,HZ/2);
 241         char* sel_file;
 242
 243         gui_synclist_do_button(&playlist_lists, &button,LIST_WRAP_UNLESS_HELD);
 244
 245         sel_file = playlists[gui_synclist_get_sel_pos(&playlist_lists)];
 246
 247         switch (button)
 248         {
 249             case ACTION_STD_CANCEL:
 250                 exit = true;
 251                 break;
 252
 253             case ACTION_STD_OK:
 254                 snprintf(playlist, MAX_PATH, "%s/%s", playlist_dir, sel_file);
 255
 256                 if (view)
 257                 {
 258                     /* In view mode, selecting a playlist starts playback */
 259                     ft_play_playlist(playlist, playlist_dir, sel_file);
 260                 }
 261
 262                 result = 0;
 263                 exit = true;
 264                 break;
 265
 266             case ACTION_STD_CONTEXT:
 267                 /* context menu only available in view mode */
 268                 if (view)
 269                 {
 270                     snprintf(playlist, MAX_PATH, "%s/%s", playlist_dir,
 271                         sel_file);
 272
 273                     if (onplay(playlist, FILE_ATTR_M3U,
 274                             CONTEXT_TREE) != ONPLAY_OK)
 275                     {
 276                         result = 0;
 277                         exit = true;
 278                     }
 279                     else
 280                         gui_synclist_draw(&playlist_lists);
 281                 }
 282                 break;
 283
 284             case ACTION_NONE:
 285                 gui_syncstatusbar_draw(&statusbars, false);
 286                 break;
 287
 288             default:
 289                 if(default_event_handler(button) == SYS_USB_CONNECTED)
 290                 {
 291                     result = -1;
 292                     exit = true;
 293                 }
 294                 break;
 295         }
 296     }
 297     return result;
 298 }
 299
 300 /* display number of tracks inserted into playlists.  Used for directory
 301    insert */
 302 static void display_insert_count(int count)
 303 {
 304     gui_syncsplash(0, str(LANG_PLAYLIST_INSERT_COUNT), count,
 305         str(LANG_OFF_ABORT));
 306 }
 307
 308 /* Add specified track into playlist.  Callback from directory insert */
 309 static int add_track_to_playlist(char* filename, void* context)
 310 {
 311     struct add_track_context* c = (struct add_track_context*) context;
 312
 313     if (fdprintf(c->fd, "%s\n", filename) <= 0)
 314         return -1;
 315
 316     (c->count)++;
 317
 318     if (((c->count)%PLAYLIST_DISPLAY_COUNT) == 0)
 319         display_insert_count(c->count);
 320
 321     return 0;
 322 }
 323
 324 /* Add "sel" file into specified "playlist".  How to insert depends on type
 325    of file */
 326 static int add_to_playlist(const char* playlist, const char* sel, int sel_attr)
 327 {
 328     int fd;
 329     int result = -1;
 330
 331     fd = open(playlist, O_CREAT|O_WRONLY|O_APPEND);
 332     if(fd < 0)
 333         return result;
 334
 335     /* In case we're in the playlist directory */
 336     reload_directory();
 337
 338     if ((sel_attr & FILE_ATTR_MASK) == FILE_ATTR_AUDIO)
 339     {
 340         /* append the selected file */
 341         if (fdprintf(fd, "%s\n", sel) > 0)
 342             result = 0;
 343     }
 344     else if ((sel_attr & FILE_ATTR_MASK) == FILE_ATTR_M3U)
 345     {
 346         /* append playlist */
 347         int f, fs, i;
 348         char buf[1024];
 349
 350         if(strcasecmp(playlist, sel) == 0)
 351             goto exit;
 352
 353         f = open(sel, O_RDONLY);
 354         if (f < 0)
 355             goto exit;
 356
 357         fs = filesize(f);
 358
 359         for (i=0; i<fs;)
 360         {
 361             int n;
 362
 363             n = read(f, buf, sizeof(buf));
 364             if (n < 0)
 365                 break;
 366
 367             if (write(fd, buf, n) < 0)
 368                 break;
 369
 370             i += n;
 371         }
 372
 373         if (i >= fs)
 374             result = 0;
 375
 376         close(f);
 377     }
 378     else if (sel_attr & ATTR_DIRECTORY)
 379     {
 380         /* search directory for tracks and append to playlist */
 381         bool recurse = false;
 382         const char *lines[] = {
 383             str(LANG_RECURSE_DIRECTORY_QUESTION), sel};
 384         const struct text_message message={lines, 2};
 385         struct add_track_context context;
 386
 387         if (global_settings.recursive_dir_insert != RECURSE_ASK)
 388             recurse = (bool)global_settings.recursive_dir_insert;
 389         else
 390         {
 391             /* Ask if user wants to recurse directory */
 392             recurse = (gui_syncyesno_run(&message, NULL, NULL)==YESNO_YES);
 393         }
 394
 395         context.fd = fd;
 396         context.count = 0;
 397
 398         display_insert_count(0);
 399
 400         result = playlist_directory_tracksearch(sel, recurse,
 401             add_track_to_playlist, &context);
 402
 403         display_insert_count(context.count);
 404     }
 405
 406 exit:
 407     close(fd);
 408     return result;
 409 }
 410
 411 bool catalog_view_playlists(void)
 412 {
 413     if (initialize_catalog() == -1)
 414         return false;
 415
 416     if (display_playlists(NULL, true) == -1)
 417         return false;
 418
 419     return true;
 420 }
 421
 422 bool catalog_add_to_a_playlist(const char* sel, int sel_attr,
 423                                bool new_playlist, char *m3u8name)
 424 {
 425     char playlist[MAX_PATH];
 426
 427     if (initialize_catalog() == -1)
 428         return false;
 429
 430     if (new_playlist)
 431     {
 432         size_t len;
 433         if (m3u8name == NULL)
 434         {
 435             snprintf(playlist, MAX_PATH, "%s/", playlist_dir);
 436             if (kbd_input(playlist, MAX_PATH))
 437                 return false;
 438         }
 439         else
 440             strcpy(playlist, m3u8name);
 441
 442         len = strlen(playlist);
 443
 444         if(len > 4 && !strcasecmp(&playlist[len-4], ".m3u"))
 445             strcat(playlist, "8");
 446         else if(len <= 5 || strcasecmp(&playlist[len-5], ".m3u8"))
 447             strcat(playlist, ".m3u8");
 448     }
 449     else
 450     {
 451         if (display_playlists(playlist, false) == -1)
 452             return false;
 453     }
 454
 455     if (add_to_playlist(playlist, sel, sel_attr) == 0)
 456     {
 457         strncpy(most_recent_playlist, playlist+playlist_dir_length+1,
 458             sizeof(most_recent_playlist));
 459         return true;
 460     }
 461     else
 462         return false;
 463 }