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 "sprintf.h"
  32 #include "misc.h"
  33 #include "screens.h"
  34 #include "splash.h"
  35 #include "list.h"
  36 #include "action.h"
  37 #include "lang.h"
  38 #include "debug.h"
  39 #include "settings.h"
  40 #include "buffer.h"
  41 #include "plugin.h"
  42 #include "playback.h"
  43 #include "cuesheet.h"
  44
  45 #define CUE_DIR ROCKBOX_DIR "/cue"
  46
  47 struct cuesheet *curr_cue;
  48
  49 #if CONFIG_CODEC != SWCODEC
  50 /* special trickery because the hwcodec playback engine is in firmware/ */
  51 static bool cuesheet_handler(const char *filename)
  52 {
  53     return cuesheet_is_enabled() && look_for_cuesheet_file(filename, NULL);
  54 }
  55 #endif
  56
  57 void cuesheet_init(void)
  58 {
  59     if (global_settings.cuesheet) {
  60         curr_cue = (struct cuesheet *)buffer_alloc(sizeof(struct cuesheet));
  61 #if CONFIG_CODEC != SWCODEC
  62         audio_set_cuesheet_callback(cuesheet_handler);
  63 #endif
  64     } else {
  65         curr_cue = NULL;
  66     }
  67 }
  68
  69 bool cuesheet_is_enabled(void)
  70 {
  71     return (curr_cue != NULL);
  72 }
  73
  74 bool look_for_cuesheet_file(const char *trackpath, char *found_cue_path)
  75 {
  76     /* DEBUGF("look for cue file\n"); */
  77
  78     char cuepath[MAX_PATH];
  79     char *dot, *slash;
  80
  81     slash = strrchr(trackpath, '/');
  82     if (!slash)
  83     {
  84         found_cue_path = NULL;
  85         return false;
  86     }
  87
  88     strncpy(cuepath, trackpath, MAX_PATH);
  89     dot = strrchr(cuepath, '.');
  90     strcpy(dot, ".cue");
  91
  92     if (!file_exists(cuepath))
  93     {
  94         strcpy(cuepath, CUE_DIR);
  95         strcat(cuepath, slash);
  96         char *dot = strrchr(cuepath, '.');
  97         strcpy(dot, ".cue");
  98         if (!file_exists(cuepath))
  99         {
 100             if (found_cue_path)
 101                 found_cue_path = NULL;
 102             return false;
 103         }
 104     }
 105
 106     if (found_cue_path)
 107         strncpy(found_cue_path, cuepath, MAX_PATH);
 108     return true;
 109 }
 110
 111 static char *skip_whitespace(char* buf)
 112 {
 113     char *r = buf;
 114     while (*r && isspace(*r))
 115         r++;
 116     return r;
 117 }
 118
 119
 120 static char *get_string(const char *line)
 121 {
 122     char *start, *end;
 123
 124     start = strchr(line, '"');
 125     if (!start)
 126     {
 127         start = strchr(line, ' ');
 128
 129         if (!start)
 130             return NULL;
 131     }
 132
 133     end = strchr(++start, '"');
 134     if (end)
 135         *end = '\0';
 136
 137     return start;
 138 }
 139
 140 /* parse cuesheet "file" and store the information in "cue" */
 141 bool parse_cuesheet(char *file, struct cuesheet *cue)
 142 {
 143     char line[MAX_PATH];
 144     char *s;
 145     bool utf8 = false;
 146
 147     DEBUGF("cue parse\n");
 148     int fd = open_utf8(file,O_RDONLY);
 149     if (fd < 0)
 150     {
 151         /* couln't open the file */
 152         return false;
 153     }
 154     if(lseek(fd, 0, SEEK_CUR) > 0)
 155         utf8 = true;
 156
 157     /* Initialization */
 158     memset(cue, 0, sizeof(struct cuesheet));
 159     strcpy(cue->path, file);
 160     cue->curr_track = cue->tracks;
 161
 162     while ( read_line(fd,line,MAX_PATH) && cue->track_count < MAX_TRACKS )
 163     {
 164         s = skip_whitespace(line);
 165
 166         if (!strncmp(s, "TRACK", 5))
 167         {
 168             cue->track_count++;
 169         }
 170         else if (!strncmp(s, "INDEX 01", 8))
 171         {
 172             s = strchr(s,' ');
 173             s = skip_whitespace(s);
 174             s = strchr(s,' ');
 175             s = skip_whitespace(s);
 176             cue->tracks[cue->track_count-1].offset = 60*1000 * atoi(s);
 177             s = strchr(s,':') + 1;
 178             cue->tracks[cue->track_count-1].offset += 1000 * atoi(s);
 179             s = strchr(s,':') + 1;
 180             cue->tracks[cue->track_count-1].offset += 13 * atoi(s);
 181         }
 182         else if (!strncmp(s, "TITLE", 5)
 183                  || !strncmp(s, "PERFORMER", 9)
 184                  || !strncmp(s, "SONGWRITER", 10))
 185         {
 186             char *dest = NULL;
 187             char *string = get_string(s);
 188             if (!string)
 189                 break;
 190
 191             switch (*s)
 192             {
 193                 case 'T': /* TITLE */
 194                     dest = (cue->track_count <= 0) ? cue->title :
 195                             cue->tracks[cue->track_count-1].title;
 196                     break;
 197
 198                 case 'P': /* PERFORMER */
 199                     dest = (cue->track_count <= 0) ? cue->performer :
 200                         cue->tracks[cue->track_count-1].performer;
 201                     break;
 202
 203                 case 'S': /* SONGWRITER */
 204                     dest = (cue->track_count <= 0) ? cue->songwriter :
 205                             cue->tracks[cue->track_count-1].songwriter;
 206                     break;
 207             }
 208
 209             if (dest)
 210             {
 211                 if (!utf8)
 212                 {
 213                     dest = iso_decode(string, dest, -1, MIN(strlen(string), MAX_NAME));
 214                     *dest = '\0';
 215                 }
 216                 else
 217                 {
 218                     strncpy(dest, string, MAX_NAME*3);
 219                     dest[MAX_NAME*3] = '\0';
 220                 }
 221             }
 222         }
 223     }
 224     close(fd);
 225
 226     /* If some songs don't have performer info, we copy the cuesheet performer */
 227     int i;
 228     for (i = 0; i < cue->track_count; i++)
 229     {
 230         if (*(cue->tracks[i].performer) == '\0')
 231             strncpy(cue->tracks[i].performer, cue->performer, MAX_NAME*3);
 232
 233         if (*(cue->tracks[i].songwriter) == '\0')
 234             strncpy(cue->tracks[i].songwriter, cue->songwriter, MAX_NAME*3);
 235     }
 236
 237     return true;
 238 }
 239
 240 /* takes care of seeking to a track in a playlist
 241  * returns false if audio  isn't playing */
 242 static bool seek(unsigned long pos)
 243 {
 244     if (!(audio_status() & AUDIO_STATUS_PLAY))
 245     {
 246         return false;
 247     }
 248     else
 249     {
 250 #if (CONFIG_CODEC == SWCODEC)
 251         audio_pre_ff_rewind();
 252         audio_ff_rewind(pos);
 253 #else
 254         audio_pause();
 255         audio_ff_rewind(pos);
 256         audio_resume();
 257 #endif
 258         return true;
 259     }
 260 }
 261
 262 /* returns the index of the track currently being played
 263    and updates the information about the current track. */
 264 int cue_find_current_track(struct cuesheet *cue, unsigned long curpos)
 265 {
 266     int i=0;
 267     while (i < cue->track_count-1 && cue->tracks[i+1].offset < curpos)
 268         i++;
 269
 270     cue->curr_track_idx = i;
 271     cue->curr_track = cue->tracks + i;
 272     return i;
 273 }
 274
 275 /* callback that gives list item titles for the cuesheet browser */
 276 static char *list_get_name_cb(int selected_item,
 277                               void *data,
 278                               char *buffer,
 279                               size_t buffer_len)
 280 {
 281     struct cuesheet *cue = (struct cuesheet *)data;
 282
 283     if (selected_item & 1)
 284         strncpy(buffer, cue->tracks[selected_item/2].title, buffer_len);
 285     else
 286         snprintf(buffer, buffer_len, "%02d. %s", selected_item/2+1,
 287                  cue->tracks[selected_item/2].performer);
 288
 289     return buffer;
 290 }
 291
 292 void browse_cuesheet(struct cuesheet *cue)
 293 {
 294     struct gui_synclist lists;
 295     int action;
 296     bool done = false;
 297     int sel;
 298     char title[MAX_PATH];
 299     char cuepath[MAX_PATH];
 300     struct mp3entry *id3 = audio_current_track();
 301
 302     snprintf(title, MAX_PATH, "%s: %s", cue->performer, cue->title);
 303     gui_synclist_init(&lists, list_get_name_cb, cue, false, 2, NULL);
 304     gui_synclist_set_nb_items(&lists, 2*cue->track_count);
 305     gui_synclist_set_title(&lists, title, 0);
 306
 307     if (id3 && *id3->path && strcmp(id3->path, "No file!"))
 308     {
 309         look_for_cuesheet_file(id3->path, cuepath);
 310     }
 311
 312     if (id3 && id3->cuesheet_type && !strcmp(cue->path, cuepath))
 313     {
 314         gui_synclist_select_item(&lists,
 315                                  2*cue_find_current_track(cue, id3->elapsed));
 316     }
 317
 318     while (!done)
 319     {
 320         gui_synclist_draw(&lists);
 321         action = get_action(CONTEXT_LIST,TIMEOUT_BLOCK);
 322         if (gui_synclist_do_button(&lists, &action, LIST_WRAP_UNLESS_HELD))
 323             continue;
 324         switch (action)
 325         {
 326             case ACTION_STD_OK:
 327                 id3 = audio_current_track();
 328                 if (id3 && *id3->path && strcmp(id3->path, "No file!"))
 329                 {
 330                     look_for_cuesheet_file(id3->path, cuepath);
 331                     if (id3->cuesheet_type && !strcmp(cue->path, cuepath))
 332                     {
 333                         sel = gui_synclist_get_sel_pos(&lists);
 334                         seek(cue->tracks[sel/2].offset);
 335                     }
 336                 }
 337                 break;
 338             case ACTION_STD_CANCEL:
 339                 done = true;
 340         }
 341     }
 342 }
 343
 344 bool display_cuesheet_content(char* filename)
 345 {
 346     size_t bufsize = 0;
 347     struct cuesheet *cue = (struct cuesheet *)plugin_get_buffer(&bufsize);
 348     if (!cue || bufsize < sizeof(struct cuesheet))
 349         return false;
 350
 351     if (!parse_cuesheet(filename, cue))
 352         return false;
 353
 354     browse_cuesheet(cue);
 355     return true;
 356 }
 357
 358 /* skips backwards or forward in the current cuesheet
 359  * the return value indicates whether we're still in a cusheet after skipping
 360  * it also returns false if we weren't in a cuesheet.
 361  * direction should be 1 or -1.
 362  */
 363 bool curr_cuesheet_skip(int direction, unsigned long curr_pos)
 364 {
 365     int track = cue_find_current_track(curr_cue, curr_pos);
 366
 367     if (direction >= 0 && track == curr_cue->track_count - 1)
 368     {
 369         /* we want to get out of the cuesheet */
 370         return false;
 371     }
 372     else
 373     {
 374         if (!(direction <= 0 && track == 0))
 375             track += direction;
 376
 377         seek(curr_cue->tracks[track].offset);
 378         return true;
 379     }
 380
 381 }
 382
 383 void cue_spoof_id3(struct cuesheet *cue, struct mp3entry *id3)
 384 {
 385     if (!cue || !cue->curr_track)
 386         return;
 387
 388     struct cue_track_info *track = cue->curr_track;
 389
 390     id3->title = *track->title ? track->title : NULL;
 391     id3->artist = *track->performer ? track->performer : NULL;
 392     id3->composer = *track->songwriter ? track->songwriter : NULL;
 393     id3->album = *cue->title ? cue->title : NULL;
 394
 395     /* if the album artist is the same as the track artist, we hide it. */
 396     if (strcmp(cue->performer, track->performer))
 397         id3->albumartist = *cue->performer ? cue->performer : NULL;
 398     else
 399         id3->albumartist = NULL;
 400
 401     int i = cue->curr_track_idx;
 402     id3->tracknum = i+1;
 403     if (id3->track_string)
 404         snprintf(id3->track_string, 10, "%d/%d", i+1, cue->track_count);
 405 }
 406
 407 #ifdef HAVE_LCD_BITMAP
 408 static inline void draw_veritcal_line_mark(struct screen * screen,
 409                                            int x, int y, int h)
 410 {
 411     screen->set_drawmode(DRMODE_COMPLEMENT);
 412     screen->vline(x, y, y+h-1);
 413 }
 414
 415 /* draw the cuesheet markers for a track of length "tracklen",
 416    between (x1,y) and (x2,y) */
 417 void cue_draw_markers(struct screen *screen, unsigned long tracklen,
 418                       int x1, int x2, int y, int h)
 419 {
 420     int i,xi;
 421     int w = x2 - x1;
 422     for (i=1; i < curr_cue->track_count; i++)
 423     {
 424         xi = x1 + (w * curr_cue->tracks[i].offset)/tracklen;
 425         draw_veritcal_line_mark(screen, xi, y, h);
 426     }
 427 }
 428 #endif