apps/cuesheet.c

   1 /***************************************************************************
   2  *             __________               __   ___.
   3  *   Open      \______   \ ____   ____ |  | _\_ |__   _______  ___
   4  *   Source     |       _//  _ \_/ ___\|  |/ /| __ \ /  _ \  \/  /
   5  *   Jukebox    |    |   (  <_> )  \___|    < | \_\ (  <_> > <  <
   6  *   Firmware   |____|_  /\____/ \___  >__|_ \|___  /\____/__/\_ \
   7  *                     \/            \/     \/    \/            \/
   8  * $Id$
   9  *
  10  * Copyright (C) 2007 Nicolas Pennequin, Jonathan Gordon
  11  *
  12  * This program is free software; you can redistribute it and/or
  13  * modify it under the terms of the GNU General Public License
  14  * as published by the Free Software Foundation; either version 2
  15  * of the License, or (at your option) any later version.
  16  *
  17  * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY
  18  * KIND, either express or implied.
  19  *
  20  ****************************************************************************/
  21
  22 #include <stdio.h>
  23 #include <stdlib.h>
  24 #include <stdbool.h>
  25 #include <ctype.h>
  26 #include <string.h>
  27 #include "system.h"
  28 #include "audio.h"
  29 #include "kernel.h"
  30 #include "logf.h"
  31 #include "misc.h"
  32 #include "screens.h"
  33 #include "list.h"
  34 #include "action.h"
  35 #include "lang.h"
  36 #include "debug.h"
  37 #include "settings.h"
  38 #include "plugin.h"
  39 #include "playback.h"
  40 #include "cuesheet.h"
  41 #include "gui/wps.h"
  42
  43 #define CUE_DIR ROCKBOX_DIR "/cue"
  44
  45 bool look_for_cuesheet_file(struct mp3entry *track_id3, struct cuesheet_file *cue_file)
  46 {
  47     /* DEBUGF("look for cue file\n"); */
  48
  49     char cuepath[MAX_PATH];
  50     char *dot, *slash;
  51
  52     if (track_id3->has_embedded_cuesheet)
  53     {
  54         cue_file->pos = track_id3->embedded_cuesheet.pos;
  55         cue_file->size = track_id3->embedded_cuesheet.size;
  56         cue_file->encoding = track_id3->embedded_cuesheet.encoding;
  57         strlcpy(cue_file->path, track_id3->path, MAX_PATH);
  58         return true;
  59     }
  60
  61     cue_file->pos = 0;
  62     cue_file->size = 0;
  63     cue_file->path[0] = '\0';
  64     slash = strrchr(track_id3->path, '/');
  65     if (!slash)
  66         return false;
  67     strlcpy(cuepath, track_id3->path, MAX_PATH);
  68     dot = strrchr(cuepath, '.');
  69     strcpy(dot, ".cue");
  70
  71     if (!file_exists(cuepath))
  72     {
  73         strcpy(cuepath, CUE_DIR);
  74         strcat(cuepath, slash);
  75         char *dot = strrchr(cuepath, '.');
  76         strcpy(dot, ".cue");
  77         if (!file_exists(cuepath))
  78             return false;
  79     }
  80
  81     strlcpy(cue_file->path, cuepath, MAX_PATH);
  82     return true;
  83 }
  84
  85 static char *get_string(const char *line)
  86 {
  87     char *start, *end;
  88
  89     start = strchr(line, '"');
  90     if (!start)
  91     {
  92         start = strchr(line, ' ');
  93
  94         if (!start)
  95             return NULL;
  96     }
  97
  98     end = strchr(++start, '"');
  99     if (end)
 100         *end = '\0';
 101
 102     return start;
 103 }
 104
 105 /* parse cuesheet "cue_file" and store the information in "cue" */
 106 bool parse_cuesheet(struct cuesheet_file *cue_file, struct cuesheet *cue)
 107 {
 108     char line[MAX_PATH];
 109     char *s;
 110     unsigned char char_enc = CHAR_ENC_ISO_8859_1;
 111     bool is_embedded = false;
 112     int line_len;
 113     int bytes_left = 0;
 114     int read_bytes = MAX_PATH;
 115     unsigned char utf16_buf[MAX_PATH];
 116
 117     int fd = open(cue_file->path, O_RDONLY, 0644);
 118     if(fd < 0)
 119         return false;
 120     if (cue_file->pos > 0)
 121     {
 122         is_embedded = true;
 123         lseek(fd, cue_file->pos, SEEK_SET);
 124         bytes_left = cue_file->size;
 125         char_enc = cue_file->encoding;
 126     }
 127
 128     /* Look for a Unicode BOM */
 129     unsigned char bom_read = 0;
 130     read(fd, line, BOM_UTF_8_SIZE);
 131     if(!memcmp(line, BOM_UTF_8, BOM_UTF_8_SIZE))
 132     {
 133         char_enc = CHAR_ENC_UTF_8;
 134         bom_read = BOM_UTF_8_SIZE;
 135     }
 136     else if(!memcmp(line, BOM_UTF_16_LE, BOM_UTF_16_SIZE))
 137     {
 138         char_enc = CHAR_ENC_UTF_16_LE;
 139         bom_read = BOM_UTF_16_SIZE;
 140     }
 141     else if(!memcmp(line, BOM_UTF_16_BE, BOM_UTF_16_SIZE))
 142     {
 143         char_enc = CHAR_ENC_UTF_16_BE;
 144         bom_read = BOM_UTF_16_SIZE;
 145     }
 146     if (bom_read < BOM_UTF_8_SIZE)
 147         lseek(fd, cue_file->pos + bom_read, SEEK_SET);
 148     if (is_embedded)
 149     {
 150         if (bom_read  > 0)
 151             bytes_left -= bom_read;
 152         if (read_bytes > bytes_left)
 153             read_bytes = bytes_left;
 154     }
 155
 156     /* Initialization */
 157     memset(cue, 0, sizeof(struct cuesheet));
 158     strcpy(cue->path, cue_file->path);
 159     cue->curr_track = cue->tracks;
 160
 161     while ((line_len = read_line(fd, line, read_bytes)) > 0
 162         && cue->track_count < MAX_TRACKS )
 163     {
 164         if (char_enc == CHAR_ENC_UTF_16_LE)
 165         {
 166             s = utf16LEdecode(line, utf16_buf, line_len);
 167             /* terminate the string at the newline */
 168             *s = '\0';
 169             strcpy(line, utf16_buf);
 170             /* chomp the trailing 0 after the newline */
 171             lseek(fd, 1, SEEK_CUR);
 172             line_len++;
 173         }
 174         else if (char_enc == CHAR_ENC_UTF_16_BE)
 175         {
 176             s = utf16BEdecode(line, utf16_buf, line_len);
 177             *s = '\0';
 178             strcpy(line, utf16_buf);
 179         }
 180         s = skip_whitespace(line);
 181
 182         if (!strncmp(s, "TRACK", 5))
 183         {
 184             cue->track_count++;
 185         }
 186         else if (!strncmp(s, "INDEX 01", 8))
 187         {
 188             s = strchr(s,' ');
 189             s = skip_whitespace(s);
 190             s = strchr(s,' ');
 191             s = skip_whitespace(s);
 192             cue->tracks[cue->track_count-1].offset = 60*1000 * atoi(s);
 193             s = strchr(s,':') + 1;
 194             cue->tracks[cue->track_count-1].offset += 1000 * atoi(s);
 195             s = strchr(s,':') + 1;
 196             cue->tracks[cue->track_count-1].offset += 13 * atoi(s);
 197         }
 198         else if (!strncmp(s, "TITLE", 5)
 199                  || !strncmp(s, "PERFORMER", 9)
 200                  || !strncmp(s, "SONGWRITER", 10))
 201         {
 202             char *dest = NULL;
 203             char *string = get_string(s);
 204             if (!string)
 205                 break;
 206
 207             switch (*s)
 208             {
 209                 case 'T': /* TITLE */
 210                     dest = (cue->track_count <= 0) ? cue->title :
 211                             cue->tracks[cue->track_count-1].title;
 212                     break;
 213
 214                 case 'P': /* PERFORMER */
 215                     dest = (cue->track_count <= 0) ? cue->performer :
 216                         cue->tracks[cue->track_count-1].performer;
 217                     break;
 218
 219                 case 'S': /* SONGWRITER */
 220                     dest = (cue->track_count <= 0) ? cue->songwriter :
 221                             cue->tracks[cue->track_count-1].songwriter;
 222                     break;
 223             }
 224
 225             if (dest)
 226             {
 227                 if (char_enc == CHAR_ENC_ISO_8859_1)
 228                 {
 229                     dest = iso_decode(string, dest, -1,
 230                         MIN(strlen(string), MAX_NAME));
 231                     *dest = '\0';
 232                 }
 233                 else
 234                 {
 235                     strlcpy(dest, string, MAX_NAME*3 + 1);
 236                 }
 237             }
 238         }
 239         if (is_embedded)
 240         {
 241             bytes_left -= line_len;
 242             if (bytes_left <= 0)
 243                 break;
 244             if (bytes_left < read_bytes)
 245                 read_bytes = bytes_left;
 246         }
 247     }
 248     close(fd);
 249
 250     /* If some songs don't have performer info, we copy the cuesheet performer */
 251     int i;
 252     for (i = 0; i < cue->track_count; i++)
 253     {
 254         if (*(cue->tracks[i].performer) == '\0')
 255             strlcpy(cue->tracks[i].performer, cue->performer, MAX_NAME*3);
 256
 257         if (*(cue->tracks[i].songwriter) == '\0')
 258             strlcpy(cue->tracks[i].songwriter, cue->songwriter, MAX_NAME*3);
 259     }
 260
 261     return true;
 262 }
 263
 264 /* takes care of seeking to a track in a playlist
 265  * returns false if audio  isn't playing */
 266 static bool seek(unsigned long pos)
 267 {
 268     if (!(audio_status() & AUDIO_STATUS_PLAY))
 269     {
 270         return false;
 271     }
 272     else
 273     {
 274 #if (CONFIG_CODEC == SWCODEC)
 275         audio_pre_ff_rewind();
 276         audio_ff_rewind(pos);
 277 #else
 278         audio_pause();
 279         audio_ff_rewind(pos);
 280         audio_resume();
 281 #endif
 282         return true;
 283     }
 284 }
 285
 286 /* returns the index of the track currently being played
 287    and updates the information about the current track. */
 288 int cue_find_current_track(struct cuesheet *cue, unsigned long curpos)
 289 {
 290     int i=0;
 291     while (i < cue->track_count-1 && cue->tracks[i+1].offset < curpos)
 292         i++;
 293
 294     cue->curr_track_idx = i;
 295     cue->curr_track = cue->tracks + i;
 296     return i;
 297 }
 298
 299 /* callback that gives list item titles for the cuesheet browser */
 300 static const char* list_get_name_cb(int selected_item,
 301                                     void *data,
 302                                     char *buffer,
 303                                     size_t buffer_len)
 304 {
 305     struct cuesheet *cue = (struct cuesheet *)data;
 306
 307     if (selected_item & 1)
 308         strlcpy(buffer, cue->tracks[selected_item/2].title, buffer_len);
 309     else
 310         snprintf(buffer, buffer_len, "%02d. %s", selected_item/2+1,
 311                  cue->tracks[selected_item/2].performer);
 312
 313     return buffer;
 314 }
 315
 316 void browse_cuesheet(struct cuesheet *cue)
 317 {
 318     struct gui_synclist lists;
 319     int action;
 320     bool done = false;
 321     int sel;
 322     char title[MAX_PATH];
 323     struct cuesheet_file cue_file;
 324     struct mp3entry *id3 = audio_current_track();
 325
 326     snprintf(title, MAX_PATH, "%s: %s", cue->performer, cue->title);
 327     gui_synclist_init(&lists, list_get_name_cb, cue, false, 2, NULL);
 328     gui_synclist_set_nb_items(&lists, 2*cue->track_count);
 329     gui_synclist_set_title(&lists, title, 0);
 330
 331
 332     if (id3)
 333     {
 334         gui_synclist_select_item(&lists,
 335                                  2*cue_find_current_track(cue, id3->elapsed));
 336     }
 337
 338     while (!done)
 339     {
 340         gui_synclist_draw(&lists);
 341         action = get_action(CONTEXT_LIST,TIMEOUT_BLOCK);
 342         if (gui_synclist_do_button(&lists, &action, LIST_WRAP_UNLESS_HELD))
 343             continue;
 344         switch (action)
 345         {
 346             case ACTION_STD_OK:
 347                 id3 = audio_current_track();
 348                 if (id3 && *id3->path && strcmp(id3->path, "No file!"))
 349                 {
 350                     look_for_cuesheet_file(id3, &cue_file);
 351                     if (id3->cuesheet && !strcmp(cue->path, cue_file.path))
 352                     {
 353                         sel = gui_synclist_get_sel_pos(&lists);
 354                         seek(cue->tracks[sel/2].offset);
 355                     }
 356                 }
 357                 break;
 358             case ACTION_STD_CANCEL:
 359                 done = true;
 360         }
 361     }
 362 }
 363
 364 bool display_cuesheet_content(char* filename)
 365 {
 366     size_t bufsize = 0;
 367     struct cuesheet_file cue_file;
 368     struct cuesheet *cue = (struct cuesheet *)plugin_get_buffer(&bufsize);
 369     if (!cue || bufsize < sizeof(struct cuesheet))
 370         return false;
 371
 372     strlcpy(cue_file.path, filename, MAX_PATH);
 373     cue_file.pos = 0;
 374     cue_file.size = 0;
 375
 376     if (!parse_cuesheet(&cue_file, cue))
 377         return false;
 378
 379     browse_cuesheet(cue);
 380     return true;
 381 }
 382
 383 /* skips backwards or forward in the current cuesheet
 384  * the return value indicates whether we're still in a cusheet after skipping
 385  * it also returns false if we weren't in a cuesheet.
 386  * direction should be 1 or -1.
 387  */
 388 bool curr_cuesheet_skip(struct cuesheet *cue, int direction, unsigned long curr_pos)
 389 {
 390     int track = cue_find_current_track(cue, curr_pos);
 391
 392     if (direction >= 0 && track == cue->track_count - 1)
 393     {
 394         /* we want to get out of the cuesheet */
 395         return false;
 396     }
 397     else
 398     {
 399         if (!(direction <= 0 && track == 0))
 400         {
 401             /* If skipping forward, skip to next cuesheet segment. If skipping
 402             backward before DEFAULT_SKIP_TRESH milliseconds have elapsed, skip
 403             to previous cuesheet segment. If skipping backward after
 404             DEFAULT_SKIP_TRESH seconds have elapsed, skip to the start of the
 405             current cuesheet segment */
 406             if (direction == 1 ||
 407                   ((curr_pos - cue->tracks[track].offset) < DEFAULT_SKIP_TRESH))
 408             {
 409                 track += direction;
 410             }
 411         }
 412
 413         seek(cue->tracks[track].offset);
 414         return true;
 415     }
 416
 417 }
 418
 419 #ifdef HAVE_LCD_BITMAP
 420 static inline void draw_veritcal_line_mark(struct screen * screen,
 421                                            int x, int y, int h)
 422 {
 423     screen->set_drawmode(DRMODE_COMPLEMENT);
 424     screen->vline(x, y, y+h-1);
 425 }
 426
 427 /* draw the cuesheet markers for a track of length "tracklen",
 428    between (x,y) and (x+w,y) */
 429 void cue_draw_markers(struct screen *screen, struct cuesheet *cue,
 430                       unsigned long tracklen,
 431                       int x, int y, int w, int h)
 432 {
 433     int i,xi;
 434     unsigned long tracklen_seconds = tracklen/1000; /* duration in seconds */
 435
 436     for (i=1; i < cue->track_count; i++)
 437     {
 438         /* Convert seconds prior to multiplication to avoid overflow. */
 439         xi = x + (w * (cue->tracks[i].offset/1000)) / tracklen_seconds;
 440         draw_veritcal_line_mark(screen, xi, y, h);
 441     }
 442 }
 443 #endif
 444
 445 bool cuesheet_subtrack_changed(struct mp3entry *id3)
 446 {
 447     struct cuesheet *cue = id3->cuesheet;
 448     if (cue && (id3->elapsed < cue->curr_track->offset
 449             || (cue->curr_track_idx < cue->track_count - 1
 450                 && id3->elapsed >= (cue->curr_track+1)->offset)))
 451     {
 452         cue_find_current_track(cue, id3->elapsed);
 453         return true;
 454     }
 455     return false;
 456 }