apps/bookmark.c

   1 /***************************************************************************
   2  *             __________               __   ___.
   3  *   Open      \______   \ ____   ____ |  | _\_ |__   _______  ___
   4  *   Source     |       _//  _ \_/ ___\|  |/ /| __ \ /  _ \  \/  /
   5  *   Jukebox    |    |   (  <_> )  \___|    < | \_\ (  <_> > <  <
   6  *   Firmware   |____|_  /\____/ \___  >__|_ \|___  /\____/__/\_ \
   7  *                     \/            \/     \/    \/            \/
   8  *
   9  * Copyright (C)2003 by Benjamin Metzler
  10  *
  11  * All files in this archive are subject to the GNU General Public License.
  12  * See the file COPYING in the source tree root for full license agreement.
  13  *
  14  * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY
  15  * KIND, either express or implied.
  16  *
  17  ****************************************************************************/
  18
  19
  20 #include <stdio.h>
  21 #include <stdlib.h>
  22 #include <string.h>
  23 #include <stdbool.h>
  24
  25 #include "applimits.h"
  26 #include "lcd.h"
  27 #include "action.h"
  28 #include "usb.h"
  29 #include "audio.h"
  30 #include "playlist.h"
  31 #include "settings.h"
  32 #include "tree.h"
  33 #include "bookmark.h"
  34 #include "dir.h"
  35 #include "status.h"
  36 #include "system.h"
  37 #include "errno.h"
  38 #include "icons.h"
  39 #include "atoi.h"
  40 #include "string.h"
  41 #include "menu.h"
  42 #include "lang.h"
  43 #include "screens.h"
  44 #include "status.h"
  45 #include "debug.h"
  46 #include "kernel.h"
  47 #include "sprintf.h"
  48 #include "talk.h"
  49 #include "misc.h"
  50 #include "abrepeat.h"
  51 #include "splash.h"
  52 #include "yesno.h"
  53
  54 #ifdef HAVE_LCD_COLOR
  55 #include "backdrop.h"
  56 #endif
  57
  58 #define MAX_BOOKMARKS 10
  59 #define MAX_BOOKMARK_SIZE  350
  60 #define RECENT_BOOKMARK_FILE ROCKBOX_DIR "/most-recent.bmark"
  61
  62 static bool  add_bookmark(const char* bookmark_file_name, const char* bookmark);
  63 static bool  check_bookmark(const char* bookmark);
  64 static char* create_bookmark(void);
  65 static bool  delete_bookmark(const char* bookmark_file_name, int bookmark_id);
  66 static void  display_bookmark(const char* bookmark,
  67                               int bookmark_id,
  68                               int bookmark_count);
  69 static void  say_bookmark(const char* bookmark,
  70                           int bookmark_id);
  71 static bool  generate_bookmark_file_name(const char *in);
  72 static char* get_bookmark(const char* bookmark_file, int bookmark_count);
  73 static bool  parse_bookmark(const char *bookmark,
  74                             int *resume_index,
  75                             int *resume_offset,
  76                             int *resume_seed,
  77                             int *resume_first_index,
  78                             char* resume_file,
  79                             unsigned int resume_file_size,
  80                             long* ms,
  81                             int * repeat_mode,
  82                             bool *shuffle,
  83                             char* file_name);
  84 static char* select_bookmark(const char* bookmark_file_name);
  85 static bool  system_check(void);
  86 static bool  write_bookmark(bool create_bookmark_file);
  87 static int   get_bookmark_count(const char* bookmark_file_name);
  88
  89 static char global_temp_buffer[MAX_PATH+1];
  90 static char global_bookmark_file_name[MAX_PATH];
  91 static char global_read_buffer[MAX_BOOKMARK_SIZE];
  92 static char global_bookmark[MAX_BOOKMARK_SIZE];
  93 static char global_filename[MAX_PATH];
  94
  95 /* ----------------------------------------------------------------------- */
  96 /* This is the interface function from the main menu.                      */
  97 /* ----------------------------------------------------------------------- */
  98 bool bookmark_create_menu(void)
  99 {
 100     write_bookmark(true);
 101     return false;
 102 }
 103
 104 /* ----------------------------------------------------------------------- */
 105 /* This function acts as the load interface from the main menu             */
 106 /* This function determines the bookmark file name and then loads that file*/
 107 /* for the user.  The user can then select a bookmark to load.             */
 108 /* If no file/directory is currently playing, the menu item does not work. */
 109 /* ----------------------------------------------------------------------- */
 110 bool bookmark_load_menu(void)
 111 {
 112     bool success = true;
 113     int  offset;
 114     int  seed;
 115     int  index;
 116     char* bookmark;
 117
 118     if(!system_check())
 119         return false;
 120     else
 121     {
 122         char* name = playlist_get_name(NULL, global_temp_buffer,
 123                                        sizeof(global_temp_buffer));
 124         if (generate_bookmark_file_name(name))
 125         {
 126             bookmark = select_bookmark(global_bookmark_file_name);
 127             if (!bookmark)
 128                 return false;  /* User exited without selecting a bookmark */
 129
 130             success = parse_bookmark(bookmark,
 131                                      &index,
 132                                      &offset,
 133                                      &seed,
 134                                      NULL,
 135                                      global_temp_buffer,
 136                                      sizeof(global_temp_buffer),
 137                                      NULL,
 138                                      &global_settings.repeat_mode,
 139                                      &global_settings.playlist_shuffle,
 140                                      global_filename);
 141         }
 142         else
 143         {
 144             /* something bad happened while creating bookmark name*/
 145             success = false;
 146         }
 147
 148         if (success)
 149             bookmark_play(global_temp_buffer, index, offset, seed,
 150                           global_filename);
 151     }
 152
 153     return success;
 154 }
 155
 156 /* ----------------------------------------------------------------------- */
 157 /* Gives the user a list of the Most Recent Bookmarks.  This is an         */
 158 /* interface function                                                      */
 159 /* ----------------------------------------------------------------------- */
 160 bool bookmark_mrb_load()
 161 {
 162     bool success = true;
 163     int  offset;
 164     int  seed;
 165     int  index;
 166     char* bookmark;
 167
 168     bookmark = select_bookmark(RECENT_BOOKMARK_FILE);
 169     if (!bookmark)
 170         return false;  /* User exited without selecting a bookmark */
 171
 172     success = parse_bookmark(bookmark,
 173                              &index,
 174                              &offset,
 175                              &seed,
 176                              NULL,
 177                              global_temp_buffer,
 178                              sizeof(global_temp_buffer),
 179                              NULL,
 180                              &global_settings.repeat_mode,
 181                              &global_settings.playlist_shuffle,
 182                              global_filename);
 183
 184     if (success)
 185         bookmark_play(global_temp_buffer, index, offset, seed,
 186                       global_filename);
 187
 188     return success;
 189 }
 190
 191
 192 /* ----------------------------------------------------------------------- */
 193 /* This function handles an autobookmark creation.  This is an interface   */
 194 /* function.                                                               */
 195 /* ----------------------------------------------------------------------- */
 196 bool bookmark_autobookmark(void)
 197 {
 198     if (!system_check())
 199         return false;
 200
 201     audio_pause();    /* first pause playback */
 202     switch (global_settings.autocreatebookmark)
 203     {
 204         case BOOKMARK_YES:
 205             return write_bookmark(true);
 206
 207         case BOOKMARK_NO:
 208             return false;
 209
 210         case BOOKMARK_RECENT_ONLY_YES:
 211             return write_bookmark(false);
 212     }
 213 #ifdef HAVE_LCD_BITMAP
 214     unsigned char *lines[]={str(LANG_AUTO_BOOKMARK_QUERY)};
 215     struct text_message message={(char **)lines, 1};
 216 #else
 217     unsigned char *lines[]={str(LANG_AUTO_BOOKMARK_QUERY),
 218                             str(LANG_RESUME_CONFIRM_PLAYER)};
 219     struct text_message message={(char **)lines, 2};
 220 #endif
 221 #ifdef HAVE_LCD_COLOR
 222     show_main_backdrop(); /* switch to main backdrop as we may come from wps */
 223 #endif
 224     gui_syncstatusbar_draw(&statusbars, false);
 225     if(gui_syncyesno_run(&message, NULL, NULL)==YESNO_YES)
 226     {
 227         if (global_settings.autocreatebookmark == BOOKMARK_RECENT_ONLY_ASK)
 228             return write_bookmark(false);
 229         else
 230             return write_bookmark(true);
 231     }
 232     return false;
 233 }
 234
 235 /* ----------------------------------------------------------------------- */
 236 /* This function takes the current current resume information and writes   */
 237 /* that to the beginning of the bookmark file.                             */
 238 /* This file will contain N number of bookmarks in the following format:   */
 239 /* resume_index*resume_offset*resume_seed*resume_first_index*              */
 240 /* resume_file*milliseconds*MP3 Title*                                     */
 241 /* ------------------------------------------------------------------------*/
 242 static bool write_bookmark(bool create_bookmark_file)
 243 {
 244     bool   success=false;
 245     char*  bookmark;
 246
 247     if (!system_check())
 248        return false; /* something didn't happen correctly, do nothing */
 249
 250     bookmark = create_bookmark();
 251     if (!bookmark)
 252        return false; /* something didn't happen correctly, do nothing */
 253
 254     if (global_settings.usemrb)
 255         success = add_bookmark(RECENT_BOOKMARK_FILE, bookmark);
 256
 257
 258     /* writing the bookmark */
 259     if (create_bookmark_file)
 260     {
 261         char* name = playlist_get_name(NULL, global_temp_buffer,
 262                                        sizeof(global_temp_buffer));
 263         if (generate_bookmark_file_name(name))
 264         {
 265             success = add_bookmark(global_bookmark_file_name, bookmark);
 266         }
 267     }
 268
 269     if (success)
 270         gui_syncsplash(HZ, true, str(LANG_BOOKMARK_CREATE_SUCCESS));
 271     else
 272         gui_syncsplash(HZ, true, str(LANG_BOOKMARK_CREATE_FAILURE));
 273
 274     return true;
 275 }
 276
 277 /* ----------------------------------------------------------------------- */
 278 /* This function adds a bookmark to a file.                                */
 279 /* ------------------------------------------------------------------------*/
 280 static bool add_bookmark(const char* bookmark_file_name, const char* bookmark)
 281 {
 282     int    temp_bookmark_file = 0;
 283     int    bookmark_file = 0;
 284     int    bookmark_count = 0;
 285     char*  playlist = NULL;
 286     char*  cp;
 287     char*  tmp;
 288     int    len = 0;
 289     bool   unique = false;
 290
 291     /* Opening up a temp bookmark file */
 292     snprintf(global_temp_buffer, sizeof(global_temp_buffer),
 293              "%s.tmp", bookmark_file_name);
 294     temp_bookmark_file = open(global_temp_buffer,
 295                               O_WRONLY | O_CREAT | O_TRUNC);
 296     if (temp_bookmark_file < 0)
 297         return false; /* can't open the temp file */
 298
 299     if (!strcmp(bookmark_file_name,RECENT_BOOKMARK_FILE) &&
 300         (global_settings.usemrb == BOOKMARK_UNIQUE_ONLY))
 301     {
 302         playlist = strchr(bookmark,'/');
 303         cp = strrchr(bookmark,';');
 304         len = cp - playlist;
 305         unique = true;
 306     }
 307
 308     /* Writing the new bookmark to the begining of the temp file */
 309     write(temp_bookmark_file, bookmark, strlen(bookmark));
 310     write(temp_bookmark_file, "\n", 1);
 311     bookmark_count++;
 312
 313     /* Reading in the previous bookmarks and writing them to the temp file */
 314     bookmark_file = open(bookmark_file_name, O_RDONLY);
 315     if (bookmark_file >= 0)
 316     {
 317         while (read_line(bookmark_file, global_read_buffer,
 318                          sizeof(global_read_buffer)))
 319         {
 320             /* The MRB has a max of MAX_BOOKMARKS in it */
 321             /* This keeps it from getting too large */
 322             if ((strcmp(bookmark_file_name,RECENT_BOOKMARK_FILE)==0))
 323             {
 324                 if(bookmark_count >= MAX_BOOKMARKS)
 325                 break;
 326             }
 327
 328             cp  = strchr(global_read_buffer,'/');
 329             tmp = strrchr(global_read_buffer,';');
 330             if (check_bookmark(global_read_buffer) &&
 331                (!unique || len != tmp -cp || strncmp(playlist,cp,len)))
 332             {
 333                 bookmark_count++;
 334                 write(temp_bookmark_file, global_read_buffer,
 335                       strlen(global_read_buffer));
 336                 write(temp_bookmark_file, "\n", 1);
 337             }
 338         }
 339         close(bookmark_file);
 340     }
 341     close(temp_bookmark_file);
 342
 343     remove(bookmark_file_name);
 344     rename(global_temp_buffer, bookmark_file_name);
 345
 346     return true;
 347 }
 348
 349
 350 /* ----------------------------------------------------------------------- */
 351 /* This function takes the system resume data and formats it into a valid  */
 352 /* bookmark.                                                               */
 353 /* ----------------------------------------------------------------------- */
 354 static char* create_bookmark()
 355 {
 356     int resume_index = 0;
 357     char *file;
 358
 359     /* grab the currently playing track */
 360     struct mp3entry *id3 = audio_current_track();
 361     if(!id3)
 362         return NULL;
 363
 364     /* Get some basic resume information */
 365     /* queue_resume and queue_resume_index are not used and can be ignored.*/
 366     playlist_get_resume_info(&resume_index);
 367
 368     /* Get the currently playing file minus the path */
 369     /* This is used when displaying the available bookmarks */
 370     file = strrchr(id3->path,'/');
 371     if(NULL == file)
 372         return NULL;
 373
 374     /* create the bookmark */
 375     snprintf(global_bookmark, sizeof(global_bookmark),
 376              "%d;%ld;%d;%d;%ld;%d;%d;%s;%s",
 377              resume_index,
 378              id3->offset,
 379              playlist_get_seed(NULL),
 380              0,
 381              id3->elapsed,
 382              global_settings.repeat_mode,
 383              global_settings.playlist_shuffle,
 384              playlist_get_name(NULL, global_temp_buffer,
 385                 sizeof(global_temp_buffer)),
 386              file+1);
 387
 388     /* checking to see if the bookmark is valid */
 389     if (check_bookmark(global_bookmark))
 390         return global_bookmark;
 391     else
 392         return NULL;
 393 }
 394
 395 static bool check_bookmark(const char* bookmark)
 396 {
 397     return parse_bookmark(bookmark,
 398                           NULL,NULL,NULL, NULL,
 399                           NULL,0,NULL,NULL,
 400                           NULL, NULL);
 401 }
 402
 403 /* ----------------------------------------------------------------------- */
 404 /* This function will determine if an autoload is necessary.  This is an   */
 405 /* interface function.                                                     */
 406 /* ------------------------------------------------------------------------*/
 407 bool bookmark_autoload(const char* file)
 408 {
 409     int  key;
 410     int  fd;
 411     int i;
 412
 413     if(global_settings.autoloadbookmark == BOOKMARK_NO)
 414         return false;
 415
 416     /*Checking to see if a bookmark file exists.*/
 417     if(!generate_bookmark_file_name(file))
 418     {
 419         return false;
 420     }
 421     fd = open(global_bookmark_file_name, O_RDONLY);
 422     if(fd<0)
 423         return false;
 424     if(-1 == lseek(fd, 0, SEEK_END))
 425     {
 426         close(fd);
 427         return false;
 428     }
 429     close(fd);
 430     if(global_settings.autoloadbookmark == BOOKMARK_YES)
 431     {
 432         return bookmark_load(global_bookmark_file_name, true);
 433     }
 434     else
 435     {
 436         /* Prompting user to confirm bookmark load */
 437         FOR_NB_SCREENS(i)
 438             screens[i].clear_display();
 439
 440         gui_syncstatusbar_draw(&statusbars, false);
 441
 442         FOR_NB_SCREENS(i)
 443         {
 444 #ifdef HAVE_LCD_BITMAP
 445             screens[i].setmargins(0, STATUSBAR_HEIGHT);
 446             screens[i].puts_scroll(0,0, str(LANG_BOOKMARK_AUTOLOAD_QUERY));
 447             screens[i].puts(0,1, str(LANG_CONFIRM_WITH_PLAY_RECORDER));
 448             screens[i].puts(0,2, str(LANG_BOOKMARK_SELECT_LIST_BOOKMARKS));
 449             screens[i].puts(0,3, str(LANG_CANCEL_WITH_ANY_RECORDER));
 450             screens[i].update();
 451 #else
 452             screens[i].puts_scroll(0,0, str(LANG_BOOKMARK_AUTOLOAD_QUERY));
 453             screens[i].puts(0,1,str(LANG_RESUME_CONFIRM_PLAYER));
 454 #endif
 455         }
 456
 457         /* Wait for a key to be pushed */
 458         key = get_action(CONTEXT_BOOKMARKSCREEN,TIMEOUT_BLOCK);
 459         switch(key)
 460         {
 461 #ifdef HAVE_LCD_BITMAP
 462             case ACTION_STD_NEXT:
 463                 action_signalscreenchange();
 464                 return bookmark_load(global_bookmark_file_name, false);
 465 #endif
 466             case ACTION_BMS_SELECT:
 467                 action_signalscreenchange();
 468                 return bookmark_load(global_bookmark_file_name, true);
 469
 470             default:
 471                 break;
 472         }
 473
 474         action_signalscreenchange();
 475         return false;
 476     }
 477 }
 478
 479 /* ----------------------------------------------------------------------- */
 480 /* This function loads the bookmark information into the resume memory.    */
 481 /* This is an interface function.                                          */
 482 /* ------------------------------------------------------------------------*/
 483 bool bookmark_load(const char* file, bool autoload)
 484 {
 485     int  fd;
 486     bool success = true;
 487     int  offset;
 488     int  seed;
 489     int  index;
 490     char* bookmark = NULL;;
 491
 492     if(autoload)
 493     {
 494         fd = open(file, O_RDONLY);
 495         if(fd >= 0)
 496         {
 497             if(read_line(fd, global_read_buffer, sizeof(global_read_buffer)))
 498                 bookmark=global_read_buffer;
 499             close(fd);
 500         }
 501     }
 502     else
 503     {
 504         /* This is not an auto-load, so list the bookmarks */
 505         bookmark=select_bookmark(file);
 506         if(!bookmark)
 507             return true;  /* User exited without selecting a bookmark */
 508     }
 509
 510     if(bookmark)
 511     {
 512         success = parse_bookmark(bookmark,
 513                                 &index,
 514                                 &offset,
 515                                 &seed,
 516                                 NULL,
 517                                 global_temp_buffer,
 518                                 sizeof(global_temp_buffer),
 519                                 NULL,
 520                                 &global_settings.repeat_mode,
 521                                 &global_settings.playlist_shuffle,
 522                                 global_filename);
 523
 524     }
 525
 526     if(success)
 527         bookmark_play(global_temp_buffer, index, offset, seed,
 528                       global_filename);
 529
 530     return success;
 531 }
 532
 533
 534 static int get_bookmark_count(const char* bookmark_file_name)
 535 {
 536     int read_count = 0;
 537     int file = open(bookmark_file_name, O_RDONLY);
 538
 539     if(file < 0)
 540         return -1;
 541
 542     /* Get the requested bookmark */
 543     while(read_line(file, global_read_buffer, sizeof(global_read_buffer)))
 544     {
 545         if(check_bookmark(global_read_buffer))
 546             read_count++;
 547     }
 548
 549     close(file);
 550     return read_count;
 551
 552
 553 }
 554
 555 /* ----------------------------------------------------------------------- */
 556 /* This displays a the bookmarks in a file and allows the user to          */
 557 /* select one to play.                                                     */
 558 /* ------------------------------------------------------------------------*/
 559 static char* select_bookmark(const char* bookmark_file_name)
 560 {
 561     int bookmark_id = 0;
 562     int bookmark_id_prev = -1;
 563     int key;
 564     char* bookmark = NULL;
 565     int bookmark_count = 0;
 566
 567 #ifdef HAVE_LCD_BITMAP
 568     int i;
 569     int x = lcd_getxmargin();
 570     int y = lcd_getymargin();
 571     FOR_NB_SCREENS(i)
 572         screens[i].setmargins(0, 0);
 573 #endif
 574
 575     bookmark_count = get_bookmark_count(bookmark_file_name);
 576     action_signalscreenchange();
 577     while(true)
 578     {
 579         if(bookmark_id < 0)
 580             bookmark_id = bookmark_count -1;
 581         if(bookmark_id >= bookmark_count)
 582             bookmark_id = 0;
 583
 584         if (bookmark_id != bookmark_id_prev)
 585         {
 586             bookmark = get_bookmark(bookmark_file_name, bookmark_id);
 587             bookmark_id_prev = bookmark_id;
 588         }
 589
 590         if (!bookmark)
 591         {
 592             /* if there were no bookmarks in the file, delete the file and exit. */
 593             if(bookmark_id <= 0)
 594             {
 595                 gui_syncsplash(HZ, true, str(LANG_BOOKMARK_LOAD_EMPTY));
 596                 remove(bookmark_file_name);
 597                 action_signalscreenchange();
 598                 return NULL;
 599             }
 600             else
 601             {
 602                bookmark_id_prev = bookmark_id;
 603                bookmark_id--;
 604             }
 605         }
 606         else
 607         {
 608             display_bookmark(bookmark, bookmark_id, bookmark_count);
 609             if (global_settings.talk_menu) /* for voice UI */
 610                 say_bookmark(bookmark, bookmark_id);
 611         }
 612
 613         /* waiting for the user to click a button */
 614         key = get_action(CONTEXT_BOOKMARKSCREEN,TIMEOUT_BLOCK);
 615         switch(key)
 616         {
 617             case ACTION_BMS_SELECT:
 618                 /* User wants to use this bookmark */
 619 #ifdef HAVE_LCD_BITMAP
 620                 if (global_settings.statusbar)
 621                 {
 622                     FOR_NB_SCREENS(i)
 623                         screens[i].setmargins(0, STATUSBAR_HEIGHT);
 624                 }
 625                 else
 626                 {
 627                    FOR_NB_SCREENS(i)
 628                         screens[i].setmargins(0, 0);
 629                 }
 630 #endif
 631                 action_signalscreenchange();
 632                 return bookmark;
 633
 634             case ACTION_BMS_DELETE:
 635                 /* User wants to delete this bookmark */
 636                 delete_bookmark(bookmark_file_name, bookmark_id);
 637                 bookmark_id_prev=-2;
 638                 bookmark_count--;
 639                 if(bookmark_id >= bookmark_count)
 640                     bookmark_id = bookmark_count -1;
 641                 break;
 642
 643             case ACTION_STD_PREV:
 644             case ACTION_STD_PREVREPEAT:
 645                 bookmark_id--;
 646                 break;
 647
 648             case ACTION_STD_NEXT:
 649             case ACTION_STD_NEXTREPEAT:
 650                 bookmark_id++;
 651                 break;
 652
 653             case ACTION_BMS_EXIT:
 654 #ifdef HAVE_LCD_BITMAP
 655                 FOR_NB_SCREENS(i)
 656                     screens[i].setmargins(x, y);
 657 #endif
 658                 action_signalscreenchange();
 659                 return NULL;
 660
 661             default:
 662                 if(default_event_handler(key) == SYS_USB_CONNECTED)
 663                 {
 664                     action_signalscreenchange();
 665                     return NULL;
 666                 }
 667                 break;
 668         }
 669     }
 670     action_signalscreenchange();
 671     return NULL;
 672 }
 673
 674
 675 /* ----------------------------------------------------------------------- */
 676 /* This function takes a location in a bookmark file and deletes that      */
 677 /* bookmark.                                                               */
 678 /* ------------------------------------------------------------------------*/
 679 static bool delete_bookmark(const char* bookmark_file_name, int bookmark_id)
 680 {
 681     int temp_bookmark_file = 0;
 682     int bookmark_file = 0;
 683     int bookmark_count = 0;
 684
 685     /* Opening up a temp bookmark file */
 686     snprintf(global_temp_buffer, sizeof(global_temp_buffer),
 687              "%s.tmp", bookmark_file_name);
 688     temp_bookmark_file = open(global_temp_buffer,
 689                               O_WRONLY | O_CREAT | O_TRUNC);
 690     bookmark_file = open(bookmark_file_name, O_RDONLY);
 691
 692     if (temp_bookmark_file < 0 || bookmark_file < 0)
 693         return false; /* can't open one of the files */
 694
 695     /* Reading in the previous bookmarks and writing them to the temp file */
 696     while (read_line(bookmark_file, global_read_buffer,
 697                      sizeof(global_read_buffer)))
 698     {
 699         /* The MRB has a max of MAX_BOOKMARKS in it */
 700         /* This keeps it from getting too large */
 701         if ((strcmp(bookmark_file_name,RECENT_BOOKMARK_FILE)==0))
 702         {
 703             if(bookmark_count >= MAX_BOOKMARKS)
 704             break;
 705         }
 706
 707         if (check_bookmark(global_read_buffer))
 708         {
 709             if (bookmark_id != bookmark_count)
 710             {
 711                 write(temp_bookmark_file, global_read_buffer,
 712                       strlen(global_read_buffer));
 713                 write(temp_bookmark_file, "\n", 1);
 714             }
 715             bookmark_count++;
 716         }
 717     }
 718
 719     close(bookmark_file);
 720     close(temp_bookmark_file);
 721
 722     remove(bookmark_file_name);
 723     rename(global_temp_buffer, bookmark_file_name);
 724
 725     return true;
 726 }
 727
 728 /* ----------------------------------------------------------------------- */
 729 /* This function parses a bookmark and displays it for the user.           */
 730 /* ------------------------------------------------------------------------*/
 731 static void display_bookmark(const char* bookmark,
 732                              int bookmark_id,
 733                              int bookmark_count)
 734 {
 735     int  resume_index = 0;
 736     long  ms = 0;
 737     int  repeat_mode = 0;
 738     bool playlist_shuffle = false;
 739     int  len;
 740     char *dot;
 741     int i;
 742
 743     /* getting the index and the time into the file */
 744     parse_bookmark(bookmark,
 745                    &resume_index, NULL, NULL, NULL, NULL, 0,
 746                    &ms, &repeat_mode, &playlist_shuffle,
 747                    global_filename);
 748
 749     FOR_NB_SCREENS(i)
 750     {
 751         screens[i].clear_display();
 752         screens[i].stop_scroll();
 753     }
 754
 755 #ifdef HAVE_LCD_BITMAP
 756     /* bookmark shuffle and repeat states*/
 757     switch (repeat_mode)
 758     {
 759 #if (AB_REPEAT_ENABLE == 1)
 760         case REPEAT_AB:
 761             statusbar_icon_play_mode(Icon_RepeatAB);
 762             break;
 763 #endif
 764
 765         case REPEAT_ONE:
 766             statusbar_icon_play_mode(Icon_RepeatOne);
 767             break;
 768
 769         case REPEAT_ALL:
 770             statusbar_icon_play_mode(Icon_Repeat);
 771             break;
 772     }
 773     if(playlist_shuffle)
 774         statusbar_icon_shuffle();
 775
 776     /* File Name */
 777     len=strlen(global_filename);
 778     if (len>3)
 779       dot=strrchr(global_filename + len - 4, '.');
 780     else
 781       dot=NULL;
 782     if (dot)
 783         *dot='\0';
 784     FOR_NB_SCREENS(i)
 785         screens[i].puts_scroll(0, 0, (unsigned char *)global_filename);
 786     if (dot)
 787         *dot='.';
 788
 789     /* bookmark number */
 790     snprintf(global_temp_buffer, sizeof(global_temp_buffer), "%s: %2d/%2d",
 791              str(LANG_BOOKMARK_SELECT_BOOKMARK_TEXT),
 792              bookmark_id + 1, bookmark_count);
 793     FOR_NB_SCREENS(i)
 794         screens[i].puts_scroll(0, 1, (unsigned char *)global_temp_buffer);
 795
 796     /* bookmark resume index */
 797     snprintf(global_temp_buffer, sizeof(global_temp_buffer), "%s: %2d",
 798              str(LANG_BOOKMARK_SELECT_INDEX_TEXT), resume_index+1);
 799     FOR_NB_SCREENS(i)
 800         screens[i].puts_scroll(0, 2, (unsigned char *)global_temp_buffer);
 801
 802     /* elapsed time*/
 803     if ( ms < 3600000 )
 804     {
 805         snprintf(global_temp_buffer, sizeof(global_temp_buffer), "%s: %ld:%02d",
 806                  str(LANG_BOOKMARK_SELECT_TIME_TEXT),
 807                  ms / 60000,
 808                  (unsigned int)(ms % 60000) / 1000);
 809         /* unsigned int: hinting for 16bits archs */
 810     }
 811     else
 812     {
 813         snprintf(global_temp_buffer, sizeof(global_temp_buffer),
 814                  "%s: %ld:%02ld:%02d",
 815                  str(LANG_BOOKMARK_SELECT_TIME_TEXT),
 816                  ms / 3600000,
 817                  ms % 3600000 / 60000,
 818                  (unsigned int)(ms % 60000) / 1000);
 819     }
 820     FOR_NB_SCREENS(i)
 821         screens[i].puts_scroll(0, 3, (unsigned char *)global_temp_buffer);
 822
 823     /* commands */
 824     FOR_NB_SCREENS(i)
 825     {
 826         screens[i].puts_scroll(0, 4, str(LANG_BOOKMARK_SELECT_PLAY));
 827         screens[i].puts_scroll(0, 5, str(LANG_BOOKMARK_SELECT_EXIT));
 828         screens[i].puts_scroll(0, 6, str(LANG_BOOKMARK_SELECT_DELETE));
 829     }
 830 #else
 831     (void)bookmark_id;
 832     len=strlen(global_filename);
 833     if (len>3)
 834       dot=strrchr(global_filename+len-4,'.');
 835     else
 836       dot=NULL;
 837     if (dot)
 838         *dot='\0';
 839     if ( ms < 3600000 )
 840     {
 841         snprintf(global_temp_buffer, sizeof(global_temp_buffer),
 842                  "%2d, %ld:%02ld, %s,",
 843                  (bookmark_count+1),
 844                  ms / 60000,
 845                  ms % 60000 / 1000,
 846                  global_filename);
 847     }
 848     else
 849     {
 850         snprintf(global_temp_buffer, sizeof(global_temp_buffer),
 851              "%2d, %ld:%02ld:%02ld, %s,",
 852              (bookmark_count+1),
 853              ms / 60000,
 854              ms % 3600000 / 60000,
 855              ms % 60000 / 1000,
 856              global_filename);
 857     }
 858
 859     gui_syncstatusbar_draw(&statusbars, false);
 860
 861     FOR_NB_SCREENS(i)
 862     {
 863         screens[i].puts_scroll(0,0,global_temp_buffer);
 864         screens[i].puts(0,1,str(LANG_RESUME_CONFIRM_PLAYER));
 865     }
 866     if (dot)
 867         *dot='.';
 868 #endif
 869
 870 #ifdef HAVE_LCD_BITMAP
 871     FOR_NB_SCREENS(i)
 872         screens[i].update();
 873 #endif
 874 }
 875
 876
 877 /* ----------------------------------------------------------------------- */
 878 /* This function parses a bookmark, says the voice UI part of it.          */
 879 /* ------------------------------------------------------------------------*/
 880 static void say_bookmark(const char* bookmark,
 881                          int bookmark_id)
 882 {
 883     int resume_index;
 884     long ms;
 885     char dir[MAX_PATH];
 886     bool enqueue = false; /* only the first voice is not queued */
 887
 888     parse_bookmark(bookmark,
 889                    &resume_index,
 890                    NULL, NULL, NULL,
 891                    dir, sizeof(dir),
 892                    &ms, NULL, NULL,
 893                    NULL);
 894 /* disabled, because transition between talkbox and voice UI clip is not nice */
 895 #if 0
 896     if (global_settings.talk_dir >= 3)
 897     {   /* "talkbox" enabled */
 898         char* last = strrchr(dir, '/');
 899         if (last)
 900         {   /* compose filename for talkbox */
 901             strncpy(last + 1, dir_thumbnail_name, sizeof(dir)-(last-dir)-1);
 902             talk_file(dir, enqueue);
 903             enqueue = true;
 904         }
 905     }
 906 #endif
 907     talk_id(VOICE_EXT_BMARK, enqueue);
 908     talk_number(bookmark_id + 1, true);
 909     talk_id(LANG_BOOKMARK_SELECT_INDEX_TEXT, true);
 910     talk_number(resume_index + 1, true);
 911     talk_id(LANG_BOOKMARK_SELECT_TIME_TEXT, true);
 912     if (ms / 60000)
 913         talk_value(ms / 60000, UNIT_MIN, true);
 914     talk_value((ms % 60000) / 1000, UNIT_SEC, true);
 915 }
 916
 917
 918 /* ----------------------------------------------------------------------- */
 919 /* This function retrieves a given bookmark from a file.                   */
 920 /* If the bookmark requested is beyond the number of bookmarks available   */
 921 /* in the file, it will return the last one.                               */
 922 /* It also returns the index number of the bookmark in the file            */
 923 /* ------------------------------------------------------------------------*/
 924 static char* get_bookmark(const char* bookmark_file, int bookmark_count)
 925 {
 926     int read_count = -1;
 927     int result = 0;
 928     int file = open(bookmark_file, O_RDONLY);
 929
 930     if (file < 0)
 931         return NULL;
 932
 933     if (bookmark_count < 0)
 934         return NULL;
 935
 936     /* Get the requested bookmark */
 937     while (read_count < bookmark_count)
 938     {
 939         /*Reading in a single bookmark */
 940         result = read_line(file,
 941                            global_read_buffer,
 942                            sizeof(global_read_buffer));
 943
 944         /* Reading past the last bookmark in the file
 945            causes the loop to stop */
 946         if (result <= 0)
 947             break;
 948
 949         read_count++;
 950     }
 951
 952     close(file);
 953     if (read_count == bookmark_count)
 954         return global_read_buffer;
 955     else
 956         return NULL;
 957 }
 958
 959 /* ----------------------------------------------------------------------- */
 960 /* This function takes a bookmark and parses it.  This function also       */
 961 /* validates the bookmark.  Passing in NULL for an output variable         */
 962 /* indicates that value is not requested.                                  */
 963 /* ----------------------------------------------------------------------- */
 964 static bool parse_bookmark(const char *bookmark,
 965                            int *resume_index,
 966                            int *resume_offset,
 967                            int *resume_seed,
 968                            int *resume_first_index,
 969                            char* resume_file,
 970                            unsigned int resume_file_size,
 971                            long* ms,
 972                            int * repeat_mode, bool *shuffle,
 973                            char* file_name)
 974 {
 975     /* First check to see if a valid line was passed in. */
 976     int  bookmark_len                = strlen(bookmark);
 977     int  local_resume_index          = 0;
 978     int  local_resume_offset         = 0;
 979     int  local_resume_seed           = 0;
 980     int  local_resume_first_index    = 0;
 981     int  local_mS                    = 0;
 982     int  local_shuffle               = 0;
 983     int  local_repeat_mode           = 0;
 984     char* local_resume_file          = NULL;
 985     char* local_file_name            = NULL;
 986     char* field;
 987     char* end;
 988     static char bookmarkcopy[MAX_BOOKMARK_SIZE];
 989
 990     /* Don't do anything if the bookmark length is 0 */
 991     if (bookmark_len <= 0)
 992         return false;
 993
 994     /* Making a dup of the bookmark to use with strtok_r */
 995     strncpy(bookmarkcopy, bookmark, sizeof(bookmarkcopy));
 996     bookmarkcopy[sizeof(bookmarkcopy) - 1] = 0;
 997
 998     /* resume_index */
 999     if ((field = strtok_r(bookmarkcopy, ";", &end)))
1000         local_resume_index = atoi(field);
1001     else
1002         return false;
1003
1004     /* resume_offset */
1005     if ((field = strtok_r(NULL, ";", &end)))
1006         local_resume_offset = atoi(field);
1007     else
1008         return false;
1009
1010     /* resume_seed */
1011     if ((field = strtok_r(NULL, ";", &end)))
1012         local_resume_seed = atoi(field);
1013     else
1014         return false;
1015
1016     /* resume_first_index */
1017     if ((field = strtok_r(NULL, ";", &end)))
1018         local_resume_first_index = atoi(field);
1019     else
1020         return false;
1021
1022     /* Milliseconds into MP3.  Used for the bookmark select menu */
1023     if ((field = strtok_r(NULL, ";", &end)))
1024         local_mS = atoi(field);
1025     else
1026         return false;
1027
1028     /* repeat_mode */
1029     if ((field = strtok_r(NULL, ";", &end)))
1030         local_repeat_mode = atoi(field);
1031     else
1032         return false;
1033
1034     /* shuffle mode */
1035     if ((field = strtok_r(NULL, ";", &end)))
1036         local_shuffle = atoi(field);
1037     else
1038         return false;
1039
1040     /* resume_file & file_name (for the bookmark select menu)*/
1041     if (end)
1042     {
1043         local_resume_file = strtok_r(NULL, ";", &end);
1044
1045         if (end)
1046             local_file_name = strtok_r(NULL, ";", &end);
1047     }
1048     else
1049         return false;
1050
1051     /* Only return the values the calling function wants */
1052     if (resume_index)
1053         *resume_index = local_resume_index;
1054
1055     if (resume_offset)
1056         *resume_offset = local_resume_offset;
1057
1058     if (resume_seed)
1059         *resume_seed = local_resume_seed;
1060
1061     if (resume_first_index)
1062         *resume_first_index = local_resume_first_index;
1063
1064     if (resume_file && local_resume_file)
1065     {
1066         strncpy(resume_file, local_resume_file,
1067                 MIN(strlen(local_resume_file), resume_file_size-1));
1068         resume_file[MIN(strlen(local_resume_file), resume_file_size-1)]=0;
1069     }
1070
1071     if (ms)
1072         *ms = local_mS;
1073
1074     if (shuffle)
1075         *shuffle = local_shuffle;
1076
1077     if (repeat_mode)
1078         *repeat_mode = local_repeat_mode;
1079
1080     if (file_name && local_file_name)
1081     {
1082         strncpy(file_name, local_file_name,MAX_PATH-1);
1083         file_name[MAX_PATH-1] = 0;
1084     }
1085
1086     return true;
1087 }
1088
1089 /* ----------------------------------------------------------------------- */
1090 /* This function is used by multiple functions and is used to generate a   */
1091 /* bookmark named based off of the input.                                  */
1092 /* Changing this function could result in how the bookmarks are stored.    */
1093 /* it would be here that the centralized/decentralized bookmark code       */
1094 /* could be placed.                                                        */
1095 /* ----------------------------------------------------------------------- */
1096 static bool generate_bookmark_file_name(const char *in)
1097 {
1098     int len = strlen(in);
1099
1100     /* if this is a root dir MP3, rename the bookmark file root_dir.bmark */
1101     /* otherwise, name it based on the in variable */
1102     if (!strcmp("/", in))
1103         strcpy(global_bookmark_file_name, "/root_dir.bmark");
1104     else
1105     {
1106         strcpy(global_bookmark_file_name, in);
1107         if(global_bookmark_file_name[len-1] == '/')
1108             len--;
1109         strcpy(&global_bookmark_file_name[len], ".bmark");
1110     }
1111
1112     return true;
1113 }
1114
1115 /* ----------------------------------------------------------------------- */
1116 /* Returns the bookmark name for the current playlist                      */
1117 /* ----------------------------------------------------------------------- */
1118 bool bookmark_exist(void)
1119 {
1120     bool exist=false;
1121
1122     if(system_check())
1123     {
1124         char* name = playlist_get_name(NULL, global_temp_buffer,
1125                                        sizeof(global_temp_buffer));
1126         if (generate_bookmark_file_name(name))
1127         {
1128             int fd=open(global_bookmark_file_name, O_RDONLY);
1129             if (fd >=0)
1130             {
1131                 close(fd);
1132                 exist=true;
1133             }
1134         }
1135     }
1136
1137     return exist;
1138 }
1139
1140 /* ----------------------------------------------------------------------- */
1141 /* Checks the current state of the system and returns if it is in a        */
1142 /* bookmarkable state.                                                     */
1143 /* ----------------------------------------------------------------------- */
1144 /* Inputs:                                                                 */
1145 /* ----------------------------------------------------------------------- */
1146 /* Outputs:                                                                */
1147 /* return bool:  Indicates if the system was in a bookmarkable state       */
1148 /* ----------------------------------------------------------------------- */
1149 static bool system_check(void)
1150 {
1151     int resume_index = 0;
1152     struct mp3entry *id3 = audio_current_track();
1153
1154     if (!id3)
1155     {
1156         /* no track playing */
1157         return false;
1158     }
1159
1160     /* Checking to see if playing a queued track */
1161     if (playlist_get_resume_info(&resume_index) == -1)
1162     {
1163         /* something bad happened while getting the queue information */
1164         return false;
1165     }
1166     else if (playlist_modified(NULL))
1167     {
1168         /* can't bookmark while in the queue */
1169         return false;
1170     }
1171
1172     return true;
1173 }
1174