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