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