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