apps/bookmark.c

   1 /***************************************************************************
   2  *             __________               __   ___.
   3  *   Open      \______   \ ____   ____ |  | _\_ |__   _______  ___
   4  *   Source     |       _//  _ \_/ ___\|  |/ /| __ \ /  _ \  \/  /
   5  *   Jukebox    |    |   (  <_> )  \___|    < | \_\ (  <_> > <  <
   6  *   Firmware   |____|_  /\____/ \___  >__|_ \|___  /\____/__/\_ \
   7  *                     \/            \/     \/    \/            \/
   8  *
   9  * Copyright (C)2003 by Benjamin Metzler
  10  *
  11  * This program is free software; you can redistribute it and/or
  12  * modify it under the terms of the GNU General Public License
  13  * as published by the Free Software Foundation; either version 2
  14  * of the License, or (at your option) any later version.
  15  *
  16  * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY
  17  * KIND, either express or implied.
  18  *
  19  ****************************************************************************/
  20
  21 #include <stdio.h>
  22 #include <stdlib.h>
  23 #include <string.h>
  24 #include <stdbool.h>
  25
  26 #include "config.h"
  27 #include "action.h"
  28 #include "audio.h"
  29 #include "playlist.h"
  30 #include "settings.h"
  31 #include "tree.h"
  32 #include "bookmark.h"
  33 #include "system.h"
  34 #include "icons.h"
  35 #include "menu.h"
  36 #include "lang.h"
  37 #include "talk.h"
  38 #include "misc.h"
  39 #include "splash.h"
  40 #include "yesno.h"
  41 #include "list.h"
  42 #include "plugin.h"
  43 #include "file.h"
  44 #include "filefuncs.h"
  45
  46 #define MAX_BOOKMARKS 10
  47 #define MAX_BOOKMARK_SIZE  350
  48 #define RECENT_BOOKMARK_FILE ROCKBOX_DIR "/most-recent.bmark"
  49
  50 /* Used to buffer bookmarks while displaying the bookmark list. */
  51 struct bookmark_list
  52 {
  53     const char* filename;
  54     size_t buffer_size;
  55     int start;
  56     int count;
  57     int total_count;
  58     bool show_dont_resume;
  59     bool reload;
  60     bool show_playlist_name;
  61     char* items[];
  62 };
  63
  64 static bool  add_bookmark(const char* bookmark_file_name, const char* bookmark,
  65                           bool most_recent);
  66 static bool  check_bookmark(const char* bookmark);
  67 static char* create_bookmark(void);
  68 static bool  delete_bookmark(const char* bookmark_file_name, int bookmark_id);
  69 static void  say_bookmark(const char* bookmark,
  70                           int bookmark_id, bool show_playlist_name);
  71 static bool play_bookmark(const char* bookmark);
  72 static bool  generate_bookmark_file_name(const char *in);
  73 static const char* skip_token(const char* s);
  74 static const char* int_token(const char* s, int* dest);
  75 static const char* long_token(const char* s, long* dest);
  76 static const char* bool_token(const char* s, bool* dest);
  77 static bool  parse_bookmark(const char *bookmark,
  78                             int *resume_index,
  79                             int *resume_offset,
  80                             int *resume_seed,
  81                             int *resume_first_index,
  82                             char* resume_file,
  83                             unsigned int resume_file_size,
  84                             long* ms,
  85                             int * repeat_mode,
  86                             bool *shuffle,
  87                             char* file_name);
  88 static int buffer_bookmarks(struct bookmark_list* bookmarks, int first_line);
  89 static const char* get_bookmark_info(int list_index,
  90                                      void* data,
  91                                      char *buffer,
  92                                      size_t buffer_len);
  93 static char* select_bookmark(const char* bookmark_file_name, bool show_dont_resume);
  94 static bool  system_check(void);
  95 static bool  write_bookmark(bool create_bookmark_file, const char *bookmark);
  96 static int   get_bookmark_count(const char* bookmark_file_name);
  97
  98 static char global_temp_buffer[MAX_PATH+1];
  99 /* File name created by generate_bookmark_file_name */
 100 static char global_bookmark_file_name[MAX_PATH];
 101 static char global_read_buffer[MAX_BOOKMARK_SIZE];
 102 /* Bookmark created by create_bookmark*/
 103 static char global_bookmark[MAX_BOOKMARK_SIZE];
 104 /* Filename from parsed bookmark (can be made local where needed) */
 105 static char global_filename[MAX_PATH];
 106
 107 /* ----------------------------------------------------------------------- */
 108 /* This is the interface function from the main menu.                      */
 109 /* ----------------------------------------------------------------------- */
 110 bool bookmark_create_menu(void)
 111 {
 112     write_bookmark(true, create_bookmark());
 113     return false;
 114 }
 115
 116 /* ----------------------------------------------------------------------- */
 117 /* This function acts as the load interface from the main menu             */
 118 /* This function determines the bookmark file name and then loads that file*/
 119 /* for the user.  The user can then select a bookmark to load.             */
 120 /* If no file/directory is currently playing, the menu item does not work. */
 121 /* ----------------------------------------------------------------------- */
 122 bool bookmark_load_menu(void)
 123 {
 124     if (system_check())
 125     {
 126         char* name = playlist_get_name(NULL, global_temp_buffer,
 127                                        sizeof(global_temp_buffer));
 128         if (generate_bookmark_file_name(name))
 129         {
 130             char* bookmark = select_bookmark(global_bookmark_file_name, false);
 131
 132             if (bookmark != NULL)
 133             {
 134                 return play_bookmark(bookmark);
 135             }
 136         }
 137     }
 138
 139     return false;
 140 }
 141
 142 /* ----------------------------------------------------------------------- */
 143 /* Gives the user a list of the Most Recent Bookmarks.  This is an         */
 144 /* interface function                                                      */
 145 /* ----------------------------------------------------------------------- */
 146 bool bookmark_mrb_load()
 147 {
 148     char* bookmark = select_bookmark(RECENT_BOOKMARK_FILE, false);
 149
 150     if (bookmark != NULL)
 151     {
 152         return play_bookmark(bookmark);
 153     }
 154
 155     return false;
 156 }
 157
 158 /* ----------------------------------------------------------------------- */
 159 /* This function handles an autobookmark creation.  This is an interface   */
 160 /* function.                                                               */
 161 /* ----------------------------------------------------------------------- */
 162 bool bookmark_autobookmark(void)
 163 {
 164     char*  bookmark;
 165     if (!system_check())
 166         return false;
 167
 168     audio_pause();    /* first pause playback */
 169     bookmark = create_bookmark();
 170     /* Workaround for inability to speak when paused: all callers will
 171        just do audio_stop() when we return, so we can do it right
 172        away. This makes it possible to speak the "Create a Bookmark?"
 173        prompt and the "Bookmark Created" splash. */
 174     audio_stop();
 175     switch (global_settings.autocreatebookmark)
 176     {
 177         case BOOKMARK_YES:
 178             return write_bookmark(true, bookmark);
 179
 180         case BOOKMARK_NO:
 181             return false;
 182
 183         case BOOKMARK_RECENT_ONLY_YES:
 184             return write_bookmark(false, bookmark);
 185     }
 186 #ifdef HAVE_LCD_BITMAP
 187     const char *lines[]={ID2P(LANG_AUTO_BOOKMARK_QUERY)};
 188     const struct text_message message={lines, 1};
 189 #else
 190     const char *lines[]={ID2P(LANG_AUTO_BOOKMARK_QUERY),
 191                             str(LANG_CONFIRM_WITH_BUTTON)};
 192     const struct text_message message={lines, 2};
 193 #endif
 194
 195     if(gui_syncyesno_run(&message, NULL, NULL)==YESNO_YES)
 196     {
 197         if (global_settings.autocreatebookmark == BOOKMARK_RECENT_ONLY_ASK)
 198             return write_bookmark(false, bookmark);
 199         else
 200             return write_bookmark(true, bookmark);
 201     }
 202     return false;
 203 }
 204
 205 /* ----------------------------------------------------------------------- */
 206 /* This function takes the current current resume information and writes   */
 207 /* that to the beginning of the bookmark file.                             */
 208 /* This file will contain N number of bookmarks in the following format:   */
 209 /* resume_index*resume_offset*resume_seed*resume_first_index*              */
 210 /* resume_file*milliseconds*MP3 Title*                                     */
 211 /* ------------------------------------------------------------------------*/
 212 static bool write_bookmark(bool create_bookmark_file, const char *bookmark)
 213 {
 214     bool   success=false;
 215     if (!bookmark)
 216        return false; /* something didn't happen correctly, do nothing */
 217
 218     if (global_settings.usemrb)
 219         success = add_bookmark(RECENT_BOOKMARK_FILE, bookmark, true);
 220
 221
 222     /* writing the bookmark */
 223     if (create_bookmark_file)
 224     {
 225         char* name = playlist_get_name(NULL, global_temp_buffer,
 226                                        sizeof(global_temp_buffer));
 227         if (generate_bookmark_file_name(name))
 228         {
 229             success = add_bookmark(global_bookmark_file_name, bookmark, false);
 230         }
 231     }
 232
 233     splash(HZ, success ? ID2P(LANG_BOOKMARK_CREATE_SUCCESS)
 234            : ID2P(LANG_BOOKMARK_CREATE_FAILURE));
 235
 236     return true;
 237 }
 238
 239 /* ----------------------------------------------------------------------- */
 240 /* This function adds a bookmark to a file.                                */
 241 /* ------------------------------------------------------------------------*/
 242 static bool add_bookmark(const char* bookmark_file_name, const char* bookmark,
 243                          bool most_recent)
 244 {
 245     int    temp_bookmark_file = 0;
 246     int    bookmark_file = 0;
 247     int    bookmark_count = 0;
 248     char*  playlist = NULL;
 249     char*  cp;
 250     char*  tmp;
 251     int    len = 0;
 252     bool   unique = false;
 253
 254     /* Opening up a temp bookmark file */
 255     snprintf(global_temp_buffer, sizeof(global_temp_buffer),
 256              "%s.tmp", bookmark_file_name);
 257     temp_bookmark_file = open(global_temp_buffer,
 258                               O_WRONLY | O_CREAT | O_TRUNC);
 259     if (temp_bookmark_file < 0)
 260         return false; /* can't open the temp file */
 261
 262     if (most_recent && (global_settings.usemrb == BOOKMARK_UNIQUE_ONLY))
 263     {
 264         playlist = strchr(bookmark,'/');
 265         cp = strrchr(bookmark,';');
 266         len = cp - playlist;
 267         unique = true;
 268     }
 269
 270     /* Writing the new bookmark to the begining of the temp file */
 271     write(temp_bookmark_file, bookmark, strlen(bookmark));
 272     write(temp_bookmark_file, "\n", 1);
 273     bookmark_count++;
 274
 275     /* Reading in the previous bookmarks and writing them to the temp file */
 276     bookmark_file = open(bookmark_file_name, O_RDONLY);
 277     if (bookmark_file >= 0)
 278     {
 279         while (read_line(bookmark_file, global_read_buffer,
 280                          sizeof(global_read_buffer)) > 0)
 281         {
 282             /* The MRB has a max of MAX_BOOKMARKS in it */
 283             /* This keeps it from getting too large */
 284             if (most_recent && (bookmark_count >= MAX_BOOKMARKS))
 285                 break;
 286
 287             cp  = strchr(global_read_buffer,'/');
 288             tmp = strrchr(global_read_buffer,';');
 289             if (check_bookmark(global_read_buffer) &&
 290                (!unique || len != tmp -cp || strncmp(playlist,cp,len)))
 291             {
 292                 bookmark_count++;
 293                 write(temp_bookmark_file, global_read_buffer,
 294                       strlen(global_read_buffer));
 295                 write(temp_bookmark_file, "\n", 1);
 296             }
 297         }
 298         close(bookmark_file);
 299     }
 300     close(temp_bookmark_file);
 301
 302     remove(bookmark_file_name);
 303     rename(global_temp_buffer, bookmark_file_name);
 304
 305     return true;
 306 }
 307
 308
 309 /* ----------------------------------------------------------------------- */
 310 /* This function takes the system resume data and formats it into a valid  */
 311 /* bookmark.                                                               */
 312 /* ----------------------------------------------------------------------- */
 313 static char* create_bookmark()
 314 {
 315     int resume_index = 0;
 316     char *file;
 317
 318     if (!system_check())
 319         return NULL; /* something didn't happen correctly, do nothing */
 320
 321     /* grab the currently playing track */
 322     struct mp3entry *id3 = audio_current_track();
 323     if(!id3)
 324         return NULL;
 325
 326     /* Get some basic resume information */
 327     /* queue_resume and queue_resume_index are not used and can be ignored.*/
 328     playlist_get_resume_info(&resume_index);
 329
 330     /* Get the currently playing file minus the path */
 331     /* This is used when displaying the available bookmarks */
 332     file = strrchr(id3->path,'/');
 333     if(NULL == file)
 334         return NULL;
 335
 336     /* create the bookmark */
 337     snprintf(global_bookmark, sizeof(global_bookmark),
 338              "%d;%ld;%d;%d;%ld;%d;%d;%s;%s",
 339              resume_index,
 340              id3->offset,
 341              playlist_get_seed(NULL),
 342              0,
 343              id3->elapsed,
 344              global_settings.repeat_mode,
 345              global_settings.playlist_shuffle,
 346              playlist_get_name(NULL, global_temp_buffer,
 347                 sizeof(global_temp_buffer)),
 348              file+1);
 349
 350     /* checking to see if the bookmark is valid */
 351     if (check_bookmark(global_bookmark))
 352         return global_bookmark;
 353     else
 354         return NULL;
 355 }
 356
 357 static bool check_bookmark(const char* bookmark)
 358 {
 359     return parse_bookmark(bookmark,
 360                           NULL,NULL,NULL, NULL,
 361                           NULL,0,NULL,NULL,
 362                           NULL, NULL);
 363 }
 364
 365 /* ----------------------------------------------------------------------- */
 366 /* This function will determine if an autoload is necessary.  This is an   */
 367 /* interface function.                                                     */
 368 /* ------------------------------------------------------------------------*/
 369 bool bookmark_autoload(const char* file)
 370 {
 371     if(global_settings.autoloadbookmark == BOOKMARK_NO)
 372         return false;
 373
 374     /*Checking to see if a bookmark file exists.*/
 375     if(!generate_bookmark_file_name(file))
 376     {
 377         return false;
 378     }
 379
 380     if(!file_exists(global_bookmark_file_name))
 381         return false;
 382
 383     if(global_settings.autoloadbookmark == BOOKMARK_YES)
 384     {
 385         return bookmark_load(global_bookmark_file_name, true);
 386     }
 387     else
 388     {
 389         char* bookmark = select_bookmark(global_bookmark_file_name, true);
 390
 391         if (bookmark != NULL)
 392         {
 393             if (!play_bookmark(bookmark))
 394             {
 395                 /* Selected bookmark not found. */
 396                 splash(HZ*2, ID2P(LANG_NOTHING_TO_RESUME));
 397             }
 398
 399             /* Act as if autoload was done even if it failed, since the
 400              * user did make an active selection.
 401              */
 402             return true;
 403         }
 404
 405         return false;
 406     }
 407 }
 408
 409 /* ----------------------------------------------------------------------- */
 410 /* This function loads the bookmark information into the resume memory.    */
 411 /* This is an interface function.                                          */
 412 /* ------------------------------------------------------------------------*/
 413 bool bookmark_load(const char* file, bool autoload)
 414 {
 415     int  fd;
 416     char* bookmark = NULL;
 417
 418     if(autoload)
 419     {
 420         fd = open(file, O_RDONLY);
 421         if(fd >= 0)
 422         {
 423             if(read_line(fd, global_read_buffer, sizeof(global_read_buffer)) > 0)
 424                 bookmark=global_read_buffer;
 425             close(fd);
 426         }
 427     }
 428     else
 429     {
 430         /* This is not an auto-load, so list the bookmarks */
 431         bookmark = select_bookmark(file, false);
 432     }
 433
 434     if (bookmark != NULL)
 435     {
 436         if (!play_bookmark(bookmark))
 437         {
 438             /* Selected bookmark not found. */
 439             if (!autoload)
 440             {
 441                 splash(HZ*2, ID2P(LANG_NOTHING_TO_RESUME));
 442             }
 443
 444             return false;
 445         }
 446     }
 447
 448     return true;
 449 }
 450
 451
 452 static int get_bookmark_count(const char* bookmark_file_name)
 453 {
 454     int read_count = 0;
 455     int file = open(bookmark_file_name, O_RDONLY);
 456
 457     if(file < 0)
 458         return -1;
 459
 460     while(read_line(file, global_read_buffer, sizeof(global_read_buffer)) > 0)
 461     {
 462         read_count++;
 463     }
 464
 465     close(file);
 466     return read_count;
 467 }
 468
 469 static int buffer_bookmarks(struct bookmark_list* bookmarks, int first_line)
 470 {
 471     char* dest = ((char*) bookmarks) + bookmarks->buffer_size - 1;
 472     int read_count = 0;
 473     int file = open(bookmarks->filename, O_RDONLY);
 474
 475     if (file < 0)
 476     {
 477         return -1;
 478     }
 479
 480     if ((first_line != 0) && ((size_t) filesize(file) < bookmarks->buffer_size
 481             - sizeof(*bookmarks) - (sizeof(char*) * bookmarks->total_count)))
 482     {
 483         /* Entire file fits in buffer */
 484         first_line = 0;
 485     }
 486
 487     bookmarks->start = first_line;
 488     bookmarks->count = 0;
 489     bookmarks->reload = false;
 490
 491     while(read_line(file, global_read_buffer, sizeof(global_read_buffer)) > 0)
 492     {
 493         read_count++;
 494
 495         if (read_count >= first_line)
 496         {
 497             dest -= strlen(global_read_buffer) + 1;
 498
 499             if (dest < ((char*) bookmarks) + sizeof(*bookmarks)
 500                 + (sizeof(char*) * (bookmarks->count + 1)))
 501             {
 502                 break;
 503             }
 504
 505             strcpy(dest, global_read_buffer);
 506             bookmarks->items[bookmarks->count] = dest;
 507             bookmarks->count++;
 508         }
 509     }
 510
 511     close(file);
 512     return bookmarks->start + bookmarks->count;
 513 }
 514
 515 static const char* get_bookmark_info(int list_index,
 516                                      void* data,
 517                                      char *buffer,
 518                                      size_t buffer_len)
 519 {
 520     struct bookmark_list* bookmarks = (struct bookmark_list*) data;
 521     int     index = list_index / 2;
 522     int     resume_index = 0;
 523     long    resume_time = 0;
 524     bool    shuffle = false;
 525
 526     if (bookmarks->show_dont_resume)
 527     {
 528         if (index == 0)
 529         {
 530             return list_index % 2 == 0
 531                 ? (char*) str(LANG_BOOKMARK_DONT_RESUME) : " ";
 532         }
 533
 534         index--;
 535     }
 536
 537     if (bookmarks->reload || (index >= bookmarks->start + bookmarks->count)
 538         || (index < bookmarks->start))
 539     {
 540         int read_index = index;
 541
 542         /* Using count as a guide on how far to move could possibly fail
 543          * sometimes. Use byte count if that is a problem?
 544          */
 545
 546         if (read_index != 0)
 547         {
 548             /* Move count * 3 / 4 items in the direction the user is moving,
 549              * but don't go too close to the end.
 550              */
 551             int offset = bookmarks->count;
 552             int max = bookmarks->total_count - (bookmarks->count / 2);
 553
 554             if (read_index < bookmarks->start)
 555             {
 556                 offset *= 3;
 557             }
 558
 559             read_index = index - offset / 4;
 560
 561             if (read_index > max)
 562             {
 563                 read_index = max;
 564             }
 565
 566             if (read_index < 0)
 567             {
 568                 read_index = 0;
 569             }
 570         }
 571
 572         if (buffer_bookmarks(bookmarks, read_index) <= index)
 573         {
 574             return "";
 575         }
 576     }
 577
 578     if (!parse_bookmark(bookmarks->items[index - bookmarks->start],
 579         &resume_index, NULL, NULL, NULL, global_temp_buffer,
 580         sizeof(global_temp_buffer), &resume_time, NULL, &shuffle,
 581         global_filename))
 582     {
 583         return list_index % 2 == 0 ? (char*) str(LANG_BOOKMARK_INVALID) : " ";
 584     }
 585
 586     if (list_index % 2 == 0)
 587     {
 588         char *name;
 589         char *format;
 590         int len = strlen(global_temp_buffer);
 591
 592         if (bookmarks->show_playlist_name && len > 0)
 593         {
 594             name = global_temp_buffer;
 595             len--;
 596
 597             if (name[len] != '/')
 598             {
 599                 strrsplt(name, '.');
 600             }
 601             else if (len > 1)
 602             {
 603                 name[len] = '\0';
 604             }
 605
 606             if (len > 1)
 607             {
 608                 name = strrsplt(name, '/');
 609             }
 610
 611             format = "%s : %s";
 612         }
 613         else
 614         {
 615             name = global_filename;
 616             format = "%s";
 617         }
 618
 619         strrsplt(global_filename, '.');
 620         snprintf(buffer, buffer_len, format, name, global_filename);
 621         return buffer;
 622     }
 623     else
 624     {
 625         char time_buf[32];
 626
 627         format_time(time_buf, sizeof(time_buf), resume_time);
 628         snprintf(buffer, buffer_len, "%s, %d%s", time_buf, resume_index + 1,
 629             shuffle ? (char*) str(LANG_BOOKMARK_SHUFFLE) : "");
 630         return buffer;
 631     }
 632 }
 633
 634 static int bookmark_list_voice_cb(int list_index, void* data)
 635 {
 636     struct bookmark_list* bookmarks = (struct bookmark_list*) data;
 637     int index = list_index / 2;
 638
 639     if (bookmarks->show_dont_resume)
 640     {
 641         if (index == 0)
 642             return talk_id(LANG_BOOKMARK_DONT_RESUME, false);
 643         index--;
 644     }
 645     say_bookmark(bookmarks->items[index - bookmarks->start], index,
 646                  bookmarks->show_playlist_name);
 647     return 0;
 648 }
 649
 650 /* ----------------------------------------------------------------------- */
 651 /* This displays a the bookmarks in a file and allows the user to          */
 652 /* select one to play.                                                     */
 653 /* ------------------------------------------------------------------------*/
 654 static char* select_bookmark(const char* bookmark_file_name, bool show_dont_resume)
 655 {
 656     struct bookmark_list* bookmarks;
 657     struct gui_synclist list;
 658     int item = 0;
 659     int action;
 660     size_t size;
 661     bool exit = false;
 662     bool refresh = true;
 663
 664     bookmarks = plugin_get_buffer(&size);
 665     bookmarks->buffer_size = size;
 666     bookmarks->show_dont_resume = show_dont_resume;
 667     bookmarks->filename = bookmark_file_name;
 668     bookmarks->start = 0;
 669     bookmarks->show_playlist_name
 670         = strcmp(bookmark_file_name, RECENT_BOOKMARK_FILE) == 0;
 671     gui_synclist_init(&list, &get_bookmark_info, (void*) bookmarks, false, 2, NULL);
 672     if(global_settings.talk_menu)
 673         gui_synclist_set_voice_callback(&list, bookmark_list_voice_cb);
 674     gui_synclist_set_title(&list, str(LANG_BOOKMARK_SELECT_BOOKMARK),
 675         Icon_Bookmark);
 676
 677     while (!exit)
 678     {
 679
 680         if (refresh)
 681         {
 682             int count = get_bookmark_count(bookmark_file_name);
 683             bookmarks->total_count = count;
 684
 685             if (bookmarks->total_count < 1)
 686             {
 687                 /* No more bookmarks, delete file and exit */
 688                 splash(HZ, ID2P(LANG_BOOKMARK_LOAD_EMPTY));
 689                 remove(bookmark_file_name);
 690                 return NULL;
 691             }
 692
 693             if (bookmarks->show_dont_resume)
 694             {
 695                 count++;
 696                 item++;
 697             }
 698
 699             gui_synclist_set_nb_items(&list, count * 2);
 700
 701             if (item >= count)
 702             {
 703                 /* Selected item has been deleted */
 704                 item = count - 1;
 705                 gui_synclist_select_item(&list, item * 2);
 706             }
 707
 708             buffer_bookmarks(bookmarks, bookmarks->start);
 709             gui_synclist_draw(&list);
 710             cond_talk_ids_fq(VOICE_EXT_BMARK);
 711             gui_synclist_speak_item(&list);
 712             refresh = false;
 713         }
 714
 715         list_do_action(CONTEXT_BOOKMARKSCREEN, HZ / 2,
 716                        &list, &action, LIST_WRAP_UNLESS_HELD);
 717         item = gui_synclist_get_sel_pos(&list) / 2;
 718
 719         if (bookmarks->show_dont_resume)
 720         {
 721             item--;
 722         }
 723
 724         if (action == ACTION_STD_CONTEXT)
 725         {
 726             MENUITEM_STRINGLIST(menu_items, ID2P(LANG_BOOKMARK_CONTEXT_MENU),
 727                 NULL, ID2P(LANG_BOOKMARK_CONTEXT_RESUME),
 728                 ID2P(LANG_BOOKMARK_CONTEXT_DELETE));
 729             static const int menu_actions[] =
 730             {
 731                 ACTION_STD_OK, ACTION_BMS_DELETE
 732             };
 733             int selection = do_menu(&menu_items, NULL, NULL, false);
 734
 735             refresh = true;
 736
 737             if (selection >= 0 && selection <=
 738                 (int) (sizeof(menu_actions) / sizeof(menu_actions[0])))
 739             {
 740                 action = menu_actions[selection];
 741             }
 742         }
 743
 744         switch (action)
 745         {
 746         case ACTION_STD_OK:
 747             if (item >= 0)
 748             {
 749                 talk_shutup();
 750                 return bookmarks->items[item - bookmarks->start];
 751             }
 752
 753             /* Else fall through */
 754
 755         case ACTION_TREE_WPS:
 756         case ACTION_STD_CANCEL:
 757             exit = true;
 758             break;
 759
 760         case ACTION_BMS_DELETE:
 761             if (item >= 0)
 762             {
 763                 const char *lines[]={
 764                     ID2P(LANG_REALLY_DELETE)
 765                 };
 766                 const char *yes_lines[]={
 767                     ID2P(LANG_DELETING)
 768                 };
 769
 770                 const struct text_message message={lines, 1};
 771                 const struct text_message yes_message={yes_lines, 1};
 772
 773                 if(gui_syncyesno_run(&message, &yes_message, NULL)==YESNO_YES)
 774                 {
 775                     splash(0, str(LANG_DELETING));
 776                     delete_bookmark(bookmark_file_name, item);
 777                     bookmarks->reload = true;
 778                 }
 779                 refresh = true;
 780             }
 781             break;
 782
 783         default:
 784             if (default_event_handler(action) == SYS_USB_CONNECTED)
 785             {
 786                 exit = true;
 787             }
 788
 789             break;
 790         }
 791     }
 792
 793     talk_shutup();
 794     return NULL;
 795 }
 796
 797 /* ----------------------------------------------------------------------- */
 798 /* This function takes a location in a bookmark file and deletes that      */
 799 /* bookmark.                                                               */
 800 /* ------------------------------------------------------------------------*/
 801 static bool delete_bookmark(const char* bookmark_file_name, int bookmark_id)
 802 {
 803     int temp_bookmark_file = 0;
 804     int bookmark_file = 0;
 805     int bookmark_count = 0;
 806
 807     /* Opening up a temp bookmark file */
 808     snprintf(global_temp_buffer, sizeof(global_temp_buffer),
 809              "%s.tmp", bookmark_file_name);
 810     temp_bookmark_file = open(global_temp_buffer,
 811                               O_WRONLY | O_CREAT | O_TRUNC);
 812
 813     if (temp_bookmark_file < 0)
 814         return false; /* can't open the temp file */
 815
 816     /* Reading in the previous bookmarks and writing them to the temp file */
 817     bookmark_file = open(bookmark_file_name, O_RDONLY);
 818     if (bookmark_file >= 0)
 819     {
 820         while (read_line(bookmark_file, global_read_buffer,
 821                          sizeof(global_read_buffer)) > 0)
 822         {
 823             if (bookmark_id != bookmark_count)
 824             {
 825                 write(temp_bookmark_file, global_read_buffer,
 826                       strlen(global_read_buffer));
 827                 write(temp_bookmark_file, "\n", 1);
 828             }
 829             bookmark_count++;
 830         }
 831         close(bookmark_file);
 832     }
 833     close(temp_bookmark_file);
 834
 835     remove(bookmark_file_name);
 836     rename(global_temp_buffer, bookmark_file_name);
 837
 838     return true;
 839 }
 840
 841 /* ----------------------------------------------------------------------- */
 842 /* This function parses a bookmark, says the voice UI part of it.          */
 843 /* ------------------------------------------------------------------------*/
 844 static void say_bookmark(const char* bookmark,
 845                          int bookmark_id, bool show_playlist_name)
 846 {
 847     int resume_index;
 848     long ms;
 849     bool playlist_shuffle = false;
 850     bool is_dir;
 851
 852     if (!parse_bookmark(bookmark, &resume_index, NULL, NULL, NULL,
 853                         global_temp_buffer,sizeof(global_temp_buffer),
 854                         &ms, NULL, &playlist_shuffle,
 855                         global_filename))
 856     {
 857         talk_id(LANG_BOOKMARK_INVALID, false);
 858         return;
 859     }
 860
 861     talk_number(bookmark_id + 1, false);
 862
 863     is_dir = (global_temp_buffer[0]
 864               && global_temp_buffer[strlen(global_temp_buffer)-1] == '/');
 865 #if CONFIG_CODEC == SWCODEC
 866     /* HWCODEC cannot enqueue voice file entries and .talk thumbnails
 867        together, because there is no guarantee that the same mp3
 868        parameters are used. */
 869     if(show_playlist_name)
 870     {   /* It's useful to know which playlist this is */
 871         if(is_dir)
 872             talk_dir_or_spell(global_temp_buffer,
 873                               TALK_IDARRAY(VOICE_DIR), true);
 874         else talk_file_or_spell(NULL, global_temp_buffer,
 875                                 TALK_IDARRAY(LANG_PLAYLIST), true);
 876     }
 877 #else
 878     (void)show_playlist_name;
 879 #endif
 880
 881     if(playlist_shuffle)
 882         talk_id(LANG_SHUFFLE, true);
 883
 884     talk_id(VOICE_BOOKMARK_SELECT_INDEX_TEXT, true);
 885     talk_number(resume_index + 1, true);
 886     talk_id(LANG_TIME, true);
 887     talk_value(ms / 1000, UNIT_TIME, true);
 888
 889 #if CONFIG_CODEC == SWCODEC
 890     /* Track filename */
 891     if(is_dir)
 892         talk_file_or_spell(global_temp_buffer, global_filename,
 893                            TALK_IDARRAY(VOICE_FILE), true);
 894     else
 895     {   /* Unfortunately if this is a playlist, we do not know in which
 896            directory the file is and therefore cannot find the track's
 897            .talk file. */
 898         talk_id(VOICE_FILE, true);
 899         talk_spell(global_filename, true);
 900     }
 901 #endif
 902 }
 903
 904 /* ----------------------------------------------------------------------- */
 905 /* This function parses a bookmark and then plays it.                      */
 906 /* ------------------------------------------------------------------------*/
 907 static bool play_bookmark(const char* bookmark)
 908 {
 909     int index;
 910     int offset;
 911     int seed;
 912
 913     if (parse_bookmark(bookmark,
 914                        &index,
 915                        &offset,
 916                        &seed,
 917                        NULL,
 918                        global_temp_buffer,
 919                        sizeof(global_temp_buffer),
 920                        NULL,
 921                        &global_settings.repeat_mode,
 922                        &global_settings.playlist_shuffle,
 923                        global_filename))
 924     {
 925         return bookmark_play(global_temp_buffer, index, offset, seed,
 926             global_filename);
 927     }
 928
 929     return false;
 930 }
 931
 932 static const char* skip_token(const char* s)
 933 {
 934     while (*s && *s != ';')
 935     {
 936         s++;
 937     }
 938
 939     if (*s)
 940     {
 941         s++;
 942     }
 943
 944     return s;
 945 }
 946
 947 static const char* int_token(const char* s, int* dest)
 948 {
 949     if (dest != NULL)
 950     {
 951         *dest = atoi(s);
 952     }
 953
 954     return skip_token(s);
 955 }
 956
 957 static const char* long_token(const char* s, long* dest)
 958 {
 959     if (dest != NULL)
 960     {
 961         *dest = atoi(s);    /* Should be atol, but we don't have it. */
 962     }
 963
 964     return skip_token(s);
 965 }
 966
 967 static const char* bool_token(const char* s, bool* dest)
 968 {
 969     if (dest != NULL)
 970     {
 971         *dest = atoi(s) != 0;
 972     }
 973
 974     return skip_token(s);
 975 }
 976
 977 /* ----------------------------------------------------------------------- */
 978 /* This function takes a bookmark and parses it.  This function also       */
 979 /* validates the bookmark.  Passing in NULL for an output variable         */
 980 /* indicates that value is not requested.                                  */
 981 /* ----------------------------------------------------------------------- */
 982 static bool parse_bookmark(const char *bookmark,
 983                            int *resume_index,
 984                            int *resume_offset,
 985                            int *resume_seed,
 986                            int *resume_first_index,
 987                            char* resume_file,
 988                            unsigned int resume_file_size,
 989                            long* ms,
 990                            int * repeat_mode, bool *shuffle,
 991                            char* file_name)
 992 {
 993     const char* s = bookmark;
 994     const char* end;
 995
 996     s = int_token(s,  resume_index);
 997     s = int_token(s,  resume_offset);
 998     s = int_token(s,  resume_seed);
 999     s = int_token(s,  resume_first_index);
1000     s = long_token(s, ms);
1001     s = int_token(s,  repeat_mode);
1002     s = bool_token(s, shuffle);
1003
1004     if (*s == 0)
1005     {
1006         return false;
1007     }
1008
1009     end = strchr(s, ';');
1010
1011     if (resume_file != NULL)
1012     {
1013         size_t len = (end == NULL) ? strlen(s) : (size_t) (end - s);
1014         len = MIN(resume_file_size - 1, len);
1015         strlcpy(resume_file, s, len + 1);
1016     }
1017
1018     if (end != NULL && file_name != NULL)
1019     {
1020         end++;
1021         strlcpy(file_name, end, MAX_PATH);
1022     }
1023
1024     return true;
1025 }
1026
1027 /* ----------------------------------------------------------------------- */
1028 /* This function is used by multiple functions and is used to generate a   */
1029 /* bookmark named based off of the input.                                  */
1030 /* Changing this function could result in how the bookmarks are stored.    */
1031 /* it would be here that the centralized/decentralized bookmark code       */
1032 /* could be placed.                                                        */
1033 /* ----------------------------------------------------------------------- */
1034 static bool generate_bookmark_file_name(const char *in)
1035 {
1036     int len = strlen(in);
1037
1038     /* if this is a root dir MP3, rename the bookmark file root_dir.bmark */
1039     /* otherwise, name it based on the in variable */
1040     if (!strcmp("/", in))
1041         strcpy(global_bookmark_file_name, "/root_dir.bmark");
1042     else
1043     {
1044 #ifdef HAVE_MULTIVOLUME
1045         /* The "root" of an extra volume need special handling too. */
1046         bool volume_root = (strip_volume(in, global_bookmark_file_name) &&
1047             !strcmp("/", global_bookmark_file_name));
1048 #endif
1049
1050         strcpy(global_bookmark_file_name, in);
1051         if(global_bookmark_file_name[len-1] == '/')
1052             len--;
1053 #ifdef HAVE_MULTIVOLUME
1054         if (volume_root)
1055             strcpy(&global_bookmark_file_name[len], "/volume_dir.bmark");
1056         else
1057 #endif
1058             strcpy(&global_bookmark_file_name[len], ".bmark");
1059     }
1060
1061     return true;
1062 }
1063
1064 /* ----------------------------------------------------------------------- */
1065 /* Returns true if a bookmark file exists for the current playlist         */
1066 /* ----------------------------------------------------------------------- */
1067 bool bookmark_exist(void)
1068 {
1069     bool exist=false;
1070
1071     if(system_check())
1072     {
1073         char* name = playlist_get_name(NULL, global_temp_buffer,
1074                                        sizeof(global_temp_buffer));
1075         if (generate_bookmark_file_name(name))
1076         {
1077             exist = file_exists(global_bookmark_file_name);
1078         }
1079     }
1080
1081     return exist;
1082 }
1083
1084 /* ----------------------------------------------------------------------- */
1085 /* Checks the current state of the system and returns if it is in a        */
1086 /* bookmarkable state.                                                     */
1087 /* ----------------------------------------------------------------------- */
1088 /* Inputs:                                                                 */
1089 /* ----------------------------------------------------------------------- */
1090 /* Outputs:                                                                */
1091 /* return bool:  Indicates if the system was in a bookmarkable state       */
1092 /* ----------------------------------------------------------------------- */
1093 static bool system_check(void)
1094 {
1095     int resume_index = 0;
1096
1097     if (!(audio_status() && audio_current_track()))
1098     {
1099         /* no track playing */
1100         return false;
1101     }
1102
1103     /* Checking to see if playing a queued track */
1104     if (playlist_get_resume_info(&resume_index) == -1)
1105     {
1106         /* something bad happened while getting the queue information */
1107         return false;
1108     }
1109     else if (playlist_modified(NULL))
1110     {
1111         /* can't bookmark while in the queue */
1112         return false;
1113     }
1114
1115     return true;
1116 }
1117