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