apps/playback.c

   1 /***************************************************************************
   2  *             __________               __   ___.
   3  *   Open      \______   \ ____   ____ |  | _\_ |__   _______  ___
   4  *   Source     |       _//  _ \_/ ___\|  |/ /| __ \ /  _ \  \/  /
   5  *   Jukebox    |    |   (  <_> )  \___|    < | \_\ (  <_> > <  <
   6  *   Firmware   |____|_  /\____/ \___  >__|_ \|___  /\____/__/\_ \
   7  *                     \/            \/     \/    \/            \/
   8  * $Id$
   9  *
  10  * Copyright (C) 2005-2007 Miika Pekkarinen
  11  * Copyright (C) 2007-2008 Nicolas Pennequin
  12  *
  13  * This program is free software; you can redistribute it and/or
  14  * modify it under the terms of the GNU General Public License
  15  * as published by the Free Software Foundation; either version 2
  16  * of the License, or (at your option) any later version.
  17  *
  18  * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY
  19  * KIND, either express or implied.
  20  *
  21  ****************************************************************************/
  22
  23 /* TODO: Pause should be handled in here, rather than PCMBUF so that voice can
  24  * play whilst audio is paused */
  25 #include "config.h"
  26 #include "system.h"
  27 #include <string.h>
  28 #include "playback.h"
  29 #include "codec_thread.h"
  30 #include "kernel.h"
  31 #include "codecs.h"
  32 #include "buffering.h"
  33 #include "voice_thread.h"
  34 #include "usb.h"
  35 #include "ata.h"
  36 #include "playlist.h"
  37 #include "pcmbuf.h"
  38 #include "buffer.h"
  39 #include "cuesheet.h"
  40 #ifdef HAVE_TAGCACHE
  41 #include "tagcache.h"
  42 #endif
  43 #ifdef HAVE_LCD_BITMAP
  44 #ifdef HAVE_ALBUMART
  45 #include "albumart.h"
  46 #endif
  47 #endif
  48 #include "sound.h"
  49 #include "metadata.h"
  50 #include "splash.h"
  51 #include "talk.h"
  52 #include "panic.h"
  53
  54 #ifdef HAVE_RECORDING
  55 #include "pcm_record.h"
  56 #endif
  57
  58 #define PLAYBACK_VOICE
  59
  60 /* amount of guess-space to allow for codecs that must hunt and peck
  61  * for their correct seeek target, 32k seems a good size */
  62 #define AUDIO_REBUFFER_GUESS_SIZE    (1024*32)
  63
  64 /* Define LOGF_ENABLE to enable logf output in this file */
  65 /*#define LOGF_ENABLE*/
  66 #include "logf.h"
  67
  68 /* macros to enable logf for queues
  69    logging on SYS_TIMEOUT can be disabled */
  70 #ifdef SIMULATOR
  71 /* Define this for logf output of all queuing except SYS_TIMEOUT */
  72 #define PLAYBACK_LOGQUEUES
  73 /* Define this to logf SYS_TIMEOUT messages */
  74 /*#define PLAYBACK_LOGQUEUES_SYS_TIMEOUT*/
  75 #endif
  76
  77 #ifdef PLAYBACK_LOGQUEUES
  78 #define LOGFQUEUE logf
  79 #else
  80 #define LOGFQUEUE(...)
  81 #endif
  82
  83 #ifdef PLAYBACK_LOGQUEUES_SYS_TIMEOUT
  84 #define LOGFQUEUE_SYS_TIMEOUT logf
  85 #else
  86 #define LOGFQUEUE_SYS_TIMEOUT(...)
  87 #endif
  88
  89
  90 static enum filling_state {
  91     STATE_IDLE,     /* audio is stopped: nothing to do */
  92     STATE_FILLING,  /* adding tracks to the buffer */
  93     STATE_FULL,     /* can't add any more tracks */
  94     STATE_END_OF_PLAYLIST, /* all remaining tracks have been added */
  95     STATE_FINISHED, /* all remaining tracks are fully buffered */
  96     STATE_ENDING,   /* audio playback is ending */
  97 #if (CONFIG_PLATFORM & PLATFORM_NATIVE)
  98     STATE_USB,      /* USB mode, ignore most messages */
  99 #endif
 100 } filling;
 101
 102 /* As defined in plugins/lib/xxx2wav.h */
 103 #define GUARD_BUFSIZE  (32*1024)
 104
 105 bool audio_is_initialized = false;
 106 static bool audio_thread_ready SHAREDBSS_ATTR = false;
 107
 108 /* Variables are commented with the threads that use them: *
 109  * A=audio, C=codec, V=voice. A suffix of - indicates that *
 110  * the variable is read but not updated on that thread.    */
 111 /* TBD: Split out "audio" and "playback" (ie. calling) threads */
 112
 113 /* Main state control */
 114 static volatile bool playing SHAREDBSS_ATTR = false;/* Is audio playing? (A) */
 115 static volatile bool paused SHAREDBSS_ATTR = false; /* Is audio paused? (A/C-) */
 116
 117 /* Ring buffer where compressed audio and codecs are loaded */
 118 static unsigned char *filebuf = NULL;       /* Start of buffer (A/C-) */
 119 static unsigned char *malloc_buf = NULL;    /* Start of malloc buffer (A/C-) */
 120 static size_t filebuflen = 0;               /* Size of buffer (A/C-) */
 121 /* FIXME: make buf_ridx (C/A-) */
 122
 123 /* Possible arrangements of the buffer */
 124 enum audio_buffer_state
 125 {
 126     AUDIOBUF_STATE_TRASHED = -1,    /* trashed; must be reset */
 127     AUDIOBUF_STATE_INITIALIZED = 0, /* voice+audio OR audio-only */
 128     AUDIOBUF_STATE_VOICED_ONLY = 1, /* voice-only */
 129 };
 130 static int buffer_state = AUDIOBUF_STATE_TRASHED; /* Buffer state */
 131
 132 /* These are used to store the current and next (or prev if the current is the last)
 133  * mp3entry's in a round-robin system. This guarentees that the pointer returned
 134  * by audio_current/next_track will be valid for the full duration of the
 135  * currently playing track */
 136 static struct mp3entry mp3entry_buf[2];
 137 struct mp3entry *thistrack_id3,  /* the currently playing track */
 138                 *othertrack_id3; /* prev track during track-change-transition, or end of playlist,
 139                                   * next track otherwise */
 140 static struct mp3entry unbuffered_id3; /* the id3 for the first unbuffered track */
 141
 142 /* for cuesheet support */
 143 static struct cuesheet *curr_cue = NULL;
 144
 145
 146 #define MAX_MULTIPLE_AA SKINNABLE_SCREENS_COUNT
 147
 148 #ifdef HAVE_ALBUMART
 149
 150 static struct albumart_slot {
 151     struct dim dim;     /* holds width, height of the albumart */
 152     int used;           /* counter, increments if something uses it */
 153 } albumart_slots[MAX_MULTIPLE_AA];
 154
 155 #define FOREACH_ALBUMART(i) for(i = 0;i < MAX_MULTIPLE_AA; i++)
 156 #endif
 157
 158
 159 #define MAX_TRACK       128
 160 #define MAX_TRACK_MASK  (MAX_TRACK-1)
 161
 162 /* Track info structure about songs in the file buffer (A/C-) */
 163 static struct track_info {
 164     int audio_hid;             /* The ID for the track's buffer handle */
 165     int id3_hid;               /* The ID for the track's metadata handle */
 166     int codec_hid;             /* The ID for the track's codec handle */
 167 #ifdef HAVE_ALBUMART
 168     int aa_hid[MAX_MULTIPLE_AA];/* The ID for the track's album art handle */
 169 #endif
 170     int cuesheet_hid;          /* The ID for the track's parsed cueesheet handle */
 171
 172     size_t filesize;           /* File total length */
 173
 174     bool taginfo_ready;        /* Is metadata read */
 175
 176 } tracks[MAX_TRACK];
 177
 178 static volatile int track_ridx = 0;  /* Track being decoded (A/C-) */
 179 static int track_widx = 0;           /* Track being buffered (A) */
 180 #define CUR_TI (&tracks[track_ridx]) /* Playing track info pointer (A/C-) */
 181
 182 static struct track_info *prev_ti = NULL;  /* Pointer to the previously played
 183                                               track */
 184
 185 /* Information used only for filling the buffer */
 186 /* Playlist steps from playing track to next track to be buffered (A) */
 187 static int last_peek_offset = 0;
 188
 189 /* Scrobbler support */
 190 static unsigned long prev_track_elapsed = 0; /* Previous track elapsed time (C/A-)*/
 191
 192 /* Track change controls */
 193 static bool automatic_skip = false; /* Who initiated in-progress skip? (A) */
 194 extern bool track_transition;       /* Are we in a track transition? */
 195 static bool dir_skip = false;       /* Is a directory skip pending? (A) */
 196 static bool new_playlist = false;   /* Are we starting a new playlist? (A) */
 197 static int wps_offset = 0;          /* Pending track change offset, to keep WPS responsive (A) */
 198 static bool skipped_during_pause = false; /* Do we need to clear the PCM buffer when playback resumes (A) */
 199
 200 static bool start_play_g = false; /* Used by audio_load_track to notify
 201                                      audio_finish_load_track about start_play */
 202
 203 /* True when a track load is in progress, i.e. audio_load_track() has returned
 204  * but audio_finish_load_track() hasn't been called yet. Used to avoid allowing
 205  * audio_load_track() to get called twice in a row, which would cause problems.
 206  */
 207 static bool track_load_started = false;
 208
 209 #ifdef HAVE_DISK_STORAGE
 210 static size_t buffer_margin  = 5; /* Buffer margin aka anti-skip buffer (A/C-) */
 211 #endif
 212
 213 /* Event queues */
 214 struct event_queue audio_queue SHAREDBSS_ATTR;
 215 static struct event_queue pcmbuf_queue SHAREDBSS_ATTR;
 216
 217 extern struct codec_api ci;
 218 extern unsigned int codec_thread_id;
 219
 220 /* Multiple threads */
 221 /* Set the watermark to trigger buffer fill (A/C) */
 222 static void set_filebuf_watermark(void);
 223
 224 /* Audio thread */
 225 static struct queue_sender_list audio_queue_sender_list SHAREDBSS_ATTR;
 226 static long audio_stack[(DEFAULT_STACK_SIZE + 0x1000)/sizeof(long)];
 227 static const char audio_thread_name[] = "audio";
 228
 229 static void audio_thread(void);
 230 static void audio_initiate_track_change(long direction);
 231 static bool audio_have_tracks(void);
 232 static void audio_reset_buffer(void);
 233 static void audio_stop_playback(void);
 234
 235 /**************************************/
 236
 237
 238 /** Pcmbuf callbacks */
 239
 240 /* Between the codec and PCM track change, we need to keep updating the
 241  * "elapsed" value of the previous (to the codec, but current to the
 242  * user/PCM/WPS) track, so that the progressbar reaches the end.
 243  * During that transition, the WPS will display othertrack_id3. */
 244 void audio_pcmbuf_position_callback(unsigned int time)
 245 {
 246     time += othertrack_id3->elapsed;
 247     othertrack_id3->elapsed = (time >= othertrack_id3->length)
 248         ? othertrack_id3->length : time;
 249 }
 250
 251 /* Post message from pcmbuf that the end of the previous track
 252  * has just been played. */
 253 void audio_post_track_change(bool pcmbuf)
 254 {
 255     if (pcmbuf)
 256     {
 257         LOGFQUEUE("pcmbuf > pcmbuf Q_AUDIO_TRACK_CHANGED");
 258         queue_post(&pcmbuf_queue, Q_AUDIO_TRACK_CHANGED, 0);
 259     }
 260     else
 261     {
 262         LOGFQUEUE("pcmbuf > audio Q_AUDIO_TRACK_CHANGED");
 263         queue_post(&audio_queue, Q_AUDIO_TRACK_CHANGED, 0);
 264     }
 265 }
 266
 267 /* Scan the pcmbuf queue and return true if a message pulled */
 268 static bool pcmbuf_queue_scan(struct queue_event *ev)
 269 {
 270     if (!queue_empty(&pcmbuf_queue))
 271     {
 272         /* Transfer message to audio queue */
 273         pcm_play_lock();
 274         /* Pull message - never, ever any blocking call! */
 275         queue_wait_w_tmo(&pcmbuf_queue, ev, 0);
 276         pcm_play_unlock();
 277         return true;
 278     }
 279
 280     return false;
 281 }
 282
 283
 284 /** Helper functions */
 285
 286 static struct mp3entry *bufgetid3(int handle_id)
 287 {
 288     if (handle_id < 0)
 289         return NULL;
 290
 291     struct mp3entry *id3;
 292     ssize_t ret = bufgetdata(handle_id, 0, (void *)&id3);
 293
 294     if (ret != sizeof(struct mp3entry))
 295         return NULL;
 296
 297     return id3;
 298 }
 299
 300 static bool bufreadid3(int handle_id, struct mp3entry *id3out)
 301 {
 302     struct mp3entry *id3 = bufgetid3(handle_id);
 303
 304     if (id3)
 305     {
 306         copy_mp3entry(id3out, id3);
 307         return true;
 308     }
 309
 310     return false;
 311 }
 312
 313 static bool clear_track_info(struct track_info *track)
 314 {
 315     /* bufclose returns true if the handle is not found, or if it is closed
 316      * successfully, so these checks are safe on non-existant handles */
 317     if (!track)
 318         return false;
 319
 320     if (track->codec_hid >= 0) {
 321         if (bufclose(track->codec_hid))
 322             track->codec_hid = -1;
 323         else
 324             return false;
 325     }
 326
 327     if (track->id3_hid >= 0) {
 328         if (bufclose(track->id3_hid))
 329             track->id3_hid = -1;
 330         else
 331             return false;
 332     }
 333
 334     if (track->audio_hid >= 0) {
 335         if (bufclose(track->audio_hid))
 336             track->audio_hid = -1;
 337         else
 338             return false;
 339     }
 340
 341 #ifdef HAVE_ALBUMART
 342     {
 343         int i;
 344         FOREACH_ALBUMART(i)
 345         {
 346             if (track->aa_hid[i] >= 0) {
 347                 if (bufclose(track->aa_hid[i]))
 348                     track->aa_hid[i] = -1;
 349                 else
 350                     return false;
 351             }
 352         }
 353     }
 354 #endif
 355
 356     if (track->cuesheet_hid >= 0) {
 357         if (bufclose(track->cuesheet_hid))
 358             track->cuesheet_hid = -1;
 359         else
 360             return false;
 361     }
 362
 363     track->filesize = 0;
 364     track->taginfo_ready = false;
 365
 366     return true;
 367 }
 368
 369 /* --- External interfaces --- */
 370
 371 /* This sends a stop message and the audio thread will dump all it's
 372    subsequenct messages */
 373 void audio_hard_stop(void)
 374 {
 375     /* Stop playback */
 376     LOGFQUEUE("audio >| audio Q_AUDIO_STOP: 1");
 377     queue_send(&audio_queue, Q_AUDIO_STOP, 1);
 378 #ifdef PLAYBACK_VOICE
 379     voice_stop();
 380 #endif
 381 }
 382
 383 bool audio_restore_playback(int type)
 384 {
 385     switch (type)
 386     {
 387     case AUDIO_WANT_PLAYBACK:
 388         if (buffer_state != AUDIOBUF_STATE_INITIALIZED)
 389             audio_reset_buffer();
 390         return true;
 391     case AUDIO_WANT_VOICE:
 392         if (buffer_state == AUDIOBUF_STATE_TRASHED)
 393             audio_reset_buffer();
 394         return true;
 395     default:
 396         return false;
 397     }
 398 }
 399
 400 unsigned char *audio_get_buffer(bool talk_buf, size_t *buffer_size)
 401 {
 402     unsigned char *buf, *end;
 403
 404     if (audio_is_initialized)
 405     {
 406         audio_hard_stop();
 407     }
 408     /* else buffer_state will be AUDIOBUF_STATE_TRASHED at this point */
 409
 410     /* Reset the buffering thread so that it doesn't try to use the data */
 411     buffering_reset(filebuf, filebuflen);
 412
 413     if (buffer_size == NULL)
 414     {
 415         /* Special case for talk_init to use since it already knows it's
 416            trashed */
 417         buffer_state = AUDIOBUF_STATE_TRASHED;
 418         return NULL;
 419     }
 420
 421     if (talk_buf || buffer_state == AUDIOBUF_STATE_TRASHED
 422            || !talk_voice_required())
 423     {
 424         logf("get buffer: talk, audio");
 425         /* Ok to use everything from audiobuf to audiobufend - voice is loaded,
 426            the talk buffer is not needed because voice isn't being used, or
 427            could be AUDIOBUF_STATE_TRASHED already. If state is
 428            AUDIOBUF_STATE_VOICED_ONLY, no problem as long as memory isn't written
 429            without the caller knowing what's going on. Changing certain settings
 430            may move it to a worse condition but the memory in use by something
 431            else will remain undisturbed.
 432          */
 433         if (buffer_state != AUDIOBUF_STATE_TRASHED)
 434         {
 435             talk_buffer_steal();
 436             buffer_state = AUDIOBUF_STATE_TRASHED;
 437         }
 438
 439         buf = audiobuf;
 440         end = audiobufend;
 441     }
 442     else
 443     {
 444         /* Safe to just return this if already AUDIOBUF_STATE_VOICED_ONLY or
 445            still AUDIOBUF_STATE_INITIALIZED */
 446         /* Skip talk buffer and move pcm buffer to end to maximize available
 447            contiguous memory - no audio running means voice will not need the
 448            swap space */
 449         logf("get buffer: audio");
 450         buf = audiobuf + talk_get_bufsize();
 451         end = audiobufend - pcmbuf_init(audiobufend);
 452         buffer_state = AUDIOBUF_STATE_VOICED_ONLY;
 453     }
 454
 455     *buffer_size = end - buf;
 456
 457     return buf;
 458 }
 459
 460 bool audio_buffer_state_trashed(void)
 461 {
 462     return buffer_state == AUDIOBUF_STATE_TRASHED;
 463 }
 464
 465 #ifdef HAVE_RECORDING
 466 unsigned char *audio_get_recording_buffer(size_t *buffer_size)
 467 {
 468     /* Stop audio, voice and obtain all available buffer space */
 469     audio_hard_stop();
 470     talk_buffer_steal();
 471
 472     unsigned char *end = audiobufend;
 473     buffer_state = AUDIOBUF_STATE_TRASHED;
 474     *buffer_size = end - audiobuf;
 475
 476     return (unsigned char *)audiobuf;
 477 }
 478
 479 bool audio_load_encoder(int afmt)
 480 {
 481 #if (CONFIG_PLATFORM & PLATFORM_NATIVE)
 482     LOGFQUEUE("audio >| Q_AUDIO_LOAD_ENCODER: %d", afmt);
 483     return queue_send(&audio_queue, Q_AUDIO_LOAD_ENCODER, afmt) > 0;
 484 #else
 485     (void)afmt;
 486     return true;
 487 #endif
 488 } /* audio_load_encoder */
 489
 490 void audio_remove_encoder(void)
 491 {
 492 #if (CONFIG_PLATFORM & PLATFORM_NATIVE)
 493     LOGFQUEUE("audio >| Q_AUDIO_LOAD_ENCODER: NULL");
 494     queue_send(&audio_queue, Q_AUDIO_LOAD_ENCODER, AFMT_UNKNOWN);
 495 #endif
 496 } /* audio_remove_encoder */
 497
 498 #endif /* HAVE_RECORDING */
 499
 500
 501 struct mp3entry* audio_current_track(void)
 502 {
 503     const char *filename;
 504     struct playlist_track_info trackinfo;
 505     int cur_idx;
 506     int offset = ci.new_track + wps_offset;
 507     struct mp3entry *write_id3;
 508
 509     cur_idx = (track_ridx + offset) & MAX_TRACK_MASK;
 510
 511     if (cur_idx == track_ridx && *thistrack_id3->path)
 512     {
 513         /* The usual case */
 514         if (tracks[cur_idx].cuesheet_hid >= 0 && !thistrack_id3->cuesheet)
 515         {
 516             bufread(tracks[cur_idx].cuesheet_hid, sizeof(struct cuesheet), curr_cue);
 517             thistrack_id3->cuesheet = curr_cue;
 518         }
 519         return thistrack_id3;
 520     }
 521     else if (automatic_skip && offset == -1 && *othertrack_id3->path)
 522     {
 523         /* We're in a track transition. The codec has moved on to the next track,
 524              but the audio being played is still the same (now previous) track.
 525              othertrack_id3.elapsed is being updated in an ISR by
 526              codec_pcmbuf_position_callback */
 527         if (tracks[cur_idx].cuesheet_hid >= 0 && !thistrack_id3->cuesheet)
 528         {
 529             bufread(tracks[cur_idx].cuesheet_hid, sizeof(struct cuesheet), curr_cue);
 530             othertrack_id3->cuesheet = curr_cue;
 531         }
 532         return othertrack_id3;
 533     }
 534
 535     if (offset != 0)
 536     {
 537         /* Codec may be using thistrack_id3, so it must not be overwritten.
 538              If this is a manual skip, othertrack_id3 will become
 539              thistrack_id3 in audio_check_new_track().
 540            FIXME: If this is an automatic skip, it probably means multiple
 541              short tracks fit in the PCM buffer.  Overwriting othertrack_id3
 542              can lead to an incorrect value later.
 543            Note that othertrack_id3 may also be used for next track.
 544           */
 545         write_id3 = othertrack_id3;
 546     }
 547     else
 548     {
 549         write_id3 = thistrack_id3;
 550     }
 551
 552     if (tracks[cur_idx].id3_hid >= 0)
 553     {
 554         /* The current track's info has been buffered but not read yet, so get it */
 555         if (bufreadid3(tracks[cur_idx].id3_hid, write_id3))
 556             return write_id3;
 557     }
 558
 559     /* We didn't find the ID3 metadata, so we fill temp_id3 with the little info
 560        we have and return that. */
 561
 562     memset(write_id3, 0, sizeof(struct mp3entry));
 563
 564     playlist_get_track_info(NULL, playlist_next(0)+wps_offset, &trackinfo);
 565     filename = trackinfo.filename;
 566     if (!filename)
 567         filename = "No file!";
 568
 569 #if defined(HAVE_TC_RAMCACHE) && defined(HAVE_DIRCACHE)
 570     if (tagcache_fill_tags(write_id3, filename))
 571         return write_id3;
 572 #endif
 573
 574     strlcpy(write_id3->path, filename, sizeof(write_id3->path));
 575     write_id3->title = strrchr(write_id3->path, '/');
 576     if (!write_id3->title)
 577         write_id3->title = &write_id3->path[0];
 578     else
 579         write_id3->title++;
 580
 581     return write_id3;
 582 }
 583
 584 struct mp3entry* audio_next_track(void)
 585 {
 586     int next_idx;
 587     int offset = ci.new_track + wps_offset;
 588
 589     if (!audio_have_tracks())
 590         return NULL;
 591
 592     if (wps_offset == -1 && *thistrack_id3->path)
 593     {
 594         /* We're in a track transition. The next track for the WPS is the one
 595            currently being decoded. */
 596         return thistrack_id3;
 597     }
 598
 599     next_idx = (track_ridx + offset + 1) & MAX_TRACK_MASK;
 600
 601     if (tracks[next_idx].id3_hid >= 0)
 602     {
 603         if (bufreadid3(tracks[next_idx].id3_hid, othertrack_id3))
 604             return othertrack_id3;
 605         else
 606             return NULL;
 607     }
 608
 609     if (next_idx == track_widx)
 610     {
 611         /* The next track hasn't been buffered yet, so we return the static
 612            version of its metadata. */
 613         return &unbuffered_id3;
 614     }
 615
 616     return NULL;
 617 }
 618
 619 /* gets a copy of the id3 data */
 620 bool audio_peek_track(struct mp3entry* id3, int offset)
 621 {
 622     int next_idx;
 623     int new_offset = ci.new_track + wps_offset + offset;
 624
 625     if (!audio_have_tracks())
 626         return false;
 627     next_idx = (track_ridx + new_offset) & MAX_TRACK_MASK;
 628
 629     if (tracks[next_idx].id3_hid >= 0)
 630         return bufreadid3(tracks[next_idx].id3_hid, id3);
 631
 632     return false;
 633 }
 634
 635 #ifdef HAVE_ALBUMART
 636
 637 int playback_current_aa_hid(int slot)
 638 {
 639     if (slot < 0)
 640         return -1;
 641     int cur_idx;
 642     int offset = ci.new_track + wps_offset;
 643
 644     cur_idx = track_ridx + offset;
 645     cur_idx &= MAX_TRACK_MASK;
 646     return tracks[cur_idx].aa_hid[slot];
 647 }
 648
 649 int playback_claim_aa_slot(struct dim *dim)
 650 {
 651     int i;
 652
 653     /* first try to find a slot already having the size to reuse it
 654      * since we don't want albumart of the same size buffered multiple times */
 655     FOREACH_ALBUMART(i)
 656     {
 657         struct albumart_slot *slot = &albumart_slots[i];
 658         if (slot->dim.width == dim->width
 659                 && slot->dim.height == dim->height)
 660         {
 661             slot->used++;
 662             return i;
 663         }
 664     }
 665     /* size is new, find a free slot */
 666     FOREACH_ALBUMART(i)
 667     {
 668         if (!albumart_slots[i].used)
 669         {
 670             albumart_slots[i].used++;
 671             albumart_slots[i].dim = *dim;
 672             return i;
 673         }
 674     }
 675     /* sorry, no free slot */
 676     return -1;
 677 }
 678
 679 void playback_release_aa_slot(int slot)
 680 {
 681     /* invalidate the albumart_slot */
 682     struct albumart_slot *aa_slot = &albumart_slots[slot];
 683
 684     if (aa_slot->used > 0)
 685         aa_slot->used--;
 686 }
 687
 688 #endif
 689 void audio_play(long offset)
 690 {
 691     logf("audio_play");
 692
 693 #ifdef PLAYBACK_VOICE
 694     /* Truncate any existing voice output so we don't have spelling
 695      * etc. over the first part of the played track */
 696     talk_force_shutup();
 697 #endif
 698
 699     /* Start playback */
 700     LOGFQUEUE("audio >| audio Q_AUDIO_PLAY: %ld", offset);
 701     /* Don't return until playback has actually started */
 702     queue_send(&audio_queue, Q_AUDIO_PLAY, offset);
 703 }
 704
 705 void audio_stop(void)
 706 {
 707     /* Stop playback */
 708     LOGFQUEUE("audio >| audio Q_AUDIO_STOP");
 709     /* Don't return until playback has actually stopped */
 710     queue_send(&audio_queue, Q_AUDIO_STOP, 0);
 711 }
 712
 713 void audio_pause(void)
 714 {
 715     LOGFQUEUE("audio >| audio Q_AUDIO_PAUSE");
 716     /* Don't return until playback has actually paused */
 717     queue_send(&audio_queue, Q_AUDIO_PAUSE, true);
 718 }
 719
 720 void audio_resume(void)
 721 {
 722     LOGFQUEUE("audio >| audio Q_AUDIO_PAUSE resume");
 723     /* Don't return until playback has actually resumed */
 724     queue_send(&audio_queue, Q_AUDIO_PAUSE, false);
 725 }
 726
 727 void audio_skip(int direction)
 728 {
 729     if (playlist_check(ci.new_track + wps_offset + direction))
 730     {
 731         if (global_settings.beep)
 732             pcmbuf_beep(2000, 100, 2500*global_settings.beep);
 733
 734         LOGFQUEUE("audio > audio Q_AUDIO_SKIP %d", direction);
 735         queue_post(&audio_queue, Q_AUDIO_SKIP, direction);
 736         /* Update wps while our message travels inside deep playback queues. */
 737         wps_offset += direction;
 738     }
 739     else
 740     {
 741         /* No more tracks. */
 742         if (global_settings.beep)
 743             pcmbuf_beep(1000, 100, 1500*global_settings.beep);
 744     }
 745 }
 746
 747 void audio_next(void)
 748 {
 749     audio_skip(1);
 750 }
 751
 752 void audio_prev(void)
 753 {
 754     audio_skip(-1);
 755 }
 756
 757 void audio_next_dir(void)
 758 {
 759     LOGFQUEUE("audio > audio Q_AUDIO_DIR_SKIP 1");
 760     queue_post(&audio_queue, Q_AUDIO_DIR_SKIP, 1);
 761 }
 762
 763 void audio_prev_dir(void)
 764 {
 765     LOGFQUEUE("audio > audio Q_AUDIO_DIR_SKIP -1");
 766     queue_post(&audio_queue, Q_AUDIO_DIR_SKIP, -1);
 767 }
 768
 769 void audio_pre_ff_rewind(void)
 770 {
 771     LOGFQUEUE("audio > audio Q_AUDIO_PRE_FF_REWIND");
 772     queue_post(&audio_queue, Q_AUDIO_PRE_FF_REWIND, 0);
 773 }
 774
 775 void audio_ff_rewind(long newpos)
 776 {
 777     LOGFQUEUE("audio > audio Q_AUDIO_FF_REWIND");
 778     queue_post(&audio_queue, Q_AUDIO_FF_REWIND, newpos);
 779 }
 780
 781 void audio_flush_and_reload_tracks(void)
 782 {
 783     LOGFQUEUE("audio > audio Q_AUDIO_FLUSH");
 784     queue_post(&audio_queue, Q_AUDIO_FLUSH, 0);
 785 }
 786
 787 void audio_error_clear(void)
 788 {
 789 #ifdef AUDIO_HAVE_RECORDING
 790     pcm_rec_error_clear();
 791 #endif
 792 }
 793
 794 int audio_status(void)
 795 {
 796     int ret = 0;
 797
 798     if (playing)
 799         ret |= AUDIO_STATUS_PLAY;
 800
 801     if (paused)
 802         ret |= AUDIO_STATUS_PAUSE;
 803
 804 #ifdef HAVE_RECORDING
 805     /* Do this here for constitency with mpeg.c version */
 806     /* FIXME: pcm_rec_status() is deprecated */
 807     ret |= pcm_rec_status();
 808 #endif
 809
 810     return ret;
 811 }
 812
 813 bool audio_automatic_skip(void)
 814 {
 815     return automatic_skip;
 816 }
 817
 818 int audio_get_file_pos(void)
 819 {
 820     return 0;
 821 }
 822
 823 #ifdef HAVE_DISK_STORAGE
 824 void audio_set_buffer_margin(int setting)
 825 {
 826     static const unsigned short lookup[] = {5, 15, 30, 60, 120, 180, 300, 600};
 827     buffer_margin = lookup[setting];
 828     logf("buffer margin: %ld", (long)buffer_margin);
 829     set_filebuf_watermark();
 830 }
 831 #endif
 832
 833 #ifdef HAVE_CROSSFADE
 834 /* Take necessary steps to enable or disable the crossfade setting */
 835 void audio_set_crossfade(int enable)
 836 {
 837     size_t offset;
 838     bool was_playing;
 839     size_t size;
 840
 841     /* Tell it the next setting to use */
 842     pcmbuf_request_crossfade_enable(enable);
 843
 844     /* Return if size hasn't changed or this is too early to determine
 845        which in the second case there's no way we could be playing
 846        anything at all */
 847     if (pcmbuf_is_same_size()) return;
 848
 849     offset = 0;
 850     was_playing = playing;
 851
 852     /* Playback has to be stopped before changing the buffer size */
 853     if (was_playing)
 854     {
 855         /* Store the track resume position */
 856         offset = thistrack_id3->offset;
 857     }
 858
 859     /* Blast it - audio buffer will have to be setup again next time
 860        something plays */
 861     audio_get_buffer(true, &size);
 862
 863     /* Restart playback if audio was running previously */
 864     if (was_playing)
 865         audio_play(offset);
 866 }
 867 #endif
 868
 869 /* --- Routines called from multiple threads --- */
 870
 871 static void set_filebuf_watermark(void)
 872 {
 873     if (!filebuf)
 874         return;     /* Audio buffers not yet set up */
 875
 876 #ifdef HAVE_DISK_STORAGE
 877     int seconds;
 878     int spinup = ata_spinup_time();
 879     if (spinup)
 880         seconds = (spinup / HZ) + 1;
 881     else
 882         seconds = 5;
 883
 884     seconds += buffer_margin;
 885 #else
 886     /* flash storage */
 887     int seconds = 1;
 888 #endif
 889
 890     /* bitrate of last track in buffer dictates watermark */
 891     struct mp3entry* id3 = NULL;
 892     if (tracks[track_widx].taginfo_ready)
 893         id3 = bufgetid3(tracks[track_widx].id3_hid);
 894     else
 895         id3 = bufgetid3(tracks[track_widx-1].id3_hid);
 896     if (!id3) {
 897         logf("fwmark: No id3 for last track (r%d/w%d), aborting!", track_ridx, track_widx);
 898         return;
 899     }
 900     size_t bytes = id3->bitrate * (1000/8) * seconds;
 901     buf_set_watermark(bytes);
 902     logf("fwmark: %d", bytes);
 903 }
 904
 905 /* --- Buffering callbacks --- */
 906
 907 static void buffering_low_buffer_callback(void *data)
 908 {
 909     (void)data;
 910     logf("low buffer callback");
 911
 912     if (filling == STATE_FULL || filling == STATE_END_OF_PLAYLIST) {
 913         /* force a refill */
 914         LOGFQUEUE("buffering > audio Q_AUDIO_FILL_BUFFER");
 915         queue_post(&audio_queue, Q_AUDIO_FILL_BUFFER, 0);
 916     }
 917 }
 918
 919 static void buffering_handle_rebuffer_callback(void *data)
 920 {
 921     (void)data;
 922     LOGFQUEUE("audio >| audio Q_AUDIO_FLUSH");
 923     queue_post(&audio_queue, Q_AUDIO_FLUSH, 0);
 924 }
 925
 926 static void buffering_handle_finished_callback(void *data)
 927 {
 928     logf("handle %d finished buffering", *(int*)data);
 929     int hid = (*(int*)data);
 930
 931     if (hid == tracks[track_widx].id3_hid)
 932     {
 933         int offset = ci.new_track + wps_offset;
 934         int next_idx = (track_ridx + offset + 1) & MAX_TRACK_MASK;
 935         /* The metadata handle for the last loaded track has been buffered.
 936            We can ask the audio thread to load the rest of the track's data. */
 937         LOGFQUEUE("audio > audio Q_AUDIO_FINISH_LOAD");
 938         queue_post(&audio_queue, Q_AUDIO_FINISH_LOAD, 0);
 939         if (tracks[next_idx].id3_hid == hid)
 940             send_event(PLAYBACK_EVENT_NEXTTRACKID3_AVAILABLE, NULL);
 941     }
 942     else
 943     {
 944         /* This is most likely an audio handle, so we strip the useless
 945            trailing tags that are left. */
 946         strip_tags(hid);
 947
 948         if (hid == tracks[track_widx-1].audio_hid
 949             && filling == STATE_END_OF_PLAYLIST)
 950         {
 951             /* This was the last track in the playlist.
 952                We now have all the data we need. */
 953             logf("last track finished buffering");
 954             filling = STATE_FINISHED;
 955         }
 956     }
 957 }
 958
 959
 960 /* --- Audio thread --- */
 961
 962 static bool audio_have_tracks(void)
 963 {
 964     return (audio_track_count() != 0);
 965 }
 966
 967 static int audio_free_track_count(void)
 968 {
 969     /* Used tracks + free tracks adds up to MAX_TRACK - 1 */
 970     return MAX_TRACK - 1 - audio_track_count();
 971 }
 972
 973 int audio_track_count(void)
 974 {
 975     /* Calculate difference from track_ridx to track_widx
 976      * taking into account a possible wrap-around. */
 977     return (MAX_TRACK + track_widx - track_ridx) & MAX_TRACK_MASK;
 978 }
 979
 980 long audio_filebufused(void)
 981 {
 982     return (long) buf_used();
 983 }
 984
 985 /* Update track info after successful a codec track change */
 986 static void audio_update_trackinfo(void)
 987 {
 988     bool resume = false;
 989
 990     /* Load the curent track's metadata into curtrack_id3 */
 991     if (CUR_TI->id3_hid >= 0)
 992         bufreadid3(CUR_TI->id3_hid, thistrack_id3);
 993
 994     /* Reset current position */
 995     thistrack_id3->elapsed = 0;
 996
 997 #ifdef HAVE_TAGCACHE
 998     /* Ignoring resume position for automatic track change if so configured */
 999     resume = global_settings.autoresume_enable &&
1000         (!automatic_skip     /* Resume all manually selected tracks */
1001          || global_settings.autoresume_automatic == AUTORESUME_NEXTTRACK_ALWAYS
1002          || (global_settings.autoresume_automatic != AUTORESUME_NEXTTRACK_NEVER
1003                                                 /* Not never resume? */
1004              && autoresumable(thistrack_id3))); /* Pass Resume filter? */
1005 #endif
1006
1007     if (!resume)
1008     {
1009         thistrack_id3->offset = 0;
1010     }
1011
1012     logf("audio_update_trackinfo: Set offset for %s to %lX\n",
1013          thistrack_id3->title, thistrack_id3->offset);
1014
1015     /* Update the codec API */
1016     ci.filesize = CUR_TI->filesize;
1017     ci.id3 = thistrack_id3;
1018     ci.curpos = 0;
1019     ci.taginfo_ready = &CUR_TI->taginfo_ready;
1020 }
1021
1022 /* Clear tracks between write and read, non inclusive */
1023 static void audio_clear_track_entries(void)
1024 {
1025     int cur_idx = track_widx;
1026
1027     logf("Clearing tracks: r%d/w%d", track_ridx, track_widx);
1028
1029     /* Loop over all tracks from write-to-read */
1030     while (1)
1031     {
1032         cur_idx = (cur_idx + 1) & MAX_TRACK_MASK;
1033
1034         if (cur_idx == track_ridx)
1035             break;
1036
1037         clear_track_info(&tracks[cur_idx]);
1038     }
1039 }
1040
1041 /* Clear all tracks */
1042 static bool audio_release_tracks(void)
1043 {
1044     int i, cur_idx;
1045
1046     logf("releasing all tracks");
1047
1048     for(i = 0; i < MAX_TRACK; i++)
1049     {
1050         cur_idx = (track_ridx + i) & MAX_TRACK_MASK;
1051         if (!clear_track_info(&tracks[cur_idx]))
1052             return false;
1053     }
1054
1055     return true;
1056 }
1057
1058 static bool audio_loadcodec(bool start_play)
1059 {
1060     int prev_track, hid;
1061     char codec_path[MAX_PATH]; /* Full path to codec */
1062     const struct mp3entry *id3, *prev_id3;
1063
1064     if (tracks[track_widx].id3_hid < 0) {
1065         return false;
1066     }
1067
1068     id3 = bufgetid3(tracks[track_widx].id3_hid);
1069     if (!id3)
1070         return false;
1071
1072     const char *codec_fn = get_codec_filename(id3->codectype);
1073     if (codec_fn == NULL)
1074         return false;
1075
1076     tracks[track_widx].codec_hid = -1;
1077
1078     if (start_play)
1079     {
1080         /* Load the codec directly from disk and save some memory. */
1081         track_ridx = track_widx;
1082         ci.filesize = CUR_TI->filesize;
1083         ci.id3 = thistrack_id3;
1084         ci.taginfo_ready = &CUR_TI->taginfo_ready;
1085         ci.curpos = 0;
1086         return codec_load(-1, id3->codectype);
1087     }
1088     else
1089     {
1090         /* If we already have another track than this one buffered */
1091         if (track_widx != track_ridx)
1092         {
1093             prev_track = (track_widx - 1) & MAX_TRACK_MASK;
1094
1095             id3 = bufgetid3(tracks[track_widx].id3_hid);
1096             prev_id3 = bufgetid3(tracks[prev_track].id3_hid);
1097
1098             /* If the previous codec is the same as this one and the current
1099              * one is the correct one, there is no need to put another copy of
1100              * it on the file buffer */
1101             if (id3 && prev_id3)
1102             {
1103                 int codt = get_codec_base_type(id3->codectype);
1104                 int prev_codt = get_codec_base_type(prev_id3->codectype);
1105                 int cod_loaded = get_codec_base_type(codec_loaded());
1106
1107                 if (codt == prev_codt && codt == cod_loaded)
1108                 {
1109                     logf("Reusing prev. codec");
1110                     return true;
1111                 }
1112             }
1113         }
1114     }
1115
1116     codec_get_full_path(codec_path, codec_fn);
1117
1118     hid = tracks[track_widx].codec_hid = bufopen(codec_path, 0, TYPE_CODEC, NULL);
1119
1120     /* not an error if codec load it supported, will load it from disk
1121      * application builds don't support it
1122      */
1123     if (hid < 0 && hid != ERR_UNSUPPORTED_TYPE)
1124         return false;
1125
1126     if (hid >= 0)
1127         logf("Loaded codec");
1128     else
1129         logf("Buffering codec unsupported, load later from disk");
1130
1131     return true;
1132 }
1133
1134 /* Load metadata for the next track (with bufopen). The rest of the track
1135    loading will be handled by audio_finish_load_track once the metadata has been
1136    actually loaded by the buffering thread. */
1137 static bool audio_load_track(size_t offset, bool start_play)
1138 {
1139     char name_buf[MAX_PATH + 1];
1140     const char *trackname;
1141     int fd = -1;
1142
1143     if (track_load_started) {
1144         /* There is already a track load in progress, so track_widx hasn't been
1145            incremented yet. Loading another track would overwrite the one that
1146            hasn't finished loading. */
1147         logf("audio_load_track(): a track load is already in progress");
1148         return false;
1149     }
1150
1151     start_play_g = start_play;  /* will be read by audio_finish_load_track */
1152
1153     /* Stop buffer filling if there is no free track entries.
1154        Don't fill up the last track entry (we wan't to store next track
1155        metadata there). */
1156     if (!audio_free_track_count())
1157     {
1158         logf("No free tracks");
1159         return false;
1160     }
1161
1162     last_peek_offset++;
1163     tracks[track_widx].taginfo_ready = false;
1164
1165     logf("Buffering track: r%d/w%d", track_ridx, track_widx);
1166     /* Get track name from current playlist read position. */
1167     while ((trackname = playlist_peek(last_peek_offset, name_buf,
1168         sizeof(name_buf))) != NULL)
1169     {
1170         /* Handle broken playlists. */
1171         fd = open(trackname, O_RDONLY);
1172         if (fd < 0)
1173         {
1174             logf("Open failed");
1175             /* Skip invalid entry from playlist. */
1176             playlist_skip_entry(NULL, last_peek_offset);
1177         }
1178         else
1179             break;
1180     }
1181
1182     if (!trackname)
1183     {
1184         logf("End-of-playlist");
1185         memset(&unbuffered_id3, 0, sizeof(struct mp3entry));
1186         filling = STATE_END_OF_PLAYLIST;
1187
1188         if (thistrack_id3->length == 0 && thistrack_id3->filesize == 0)
1189         {
1190             /* Stop playback if no valid track was found. */
1191             audio_stop_playback();
1192         }
1193
1194         return false;
1195     }
1196
1197     tracks[track_widx].filesize = filesize(fd);
1198
1199     if (offset > tracks[track_widx].filesize)
1200         offset = 0;
1201
1202     /* Set default values */
1203     if (start_play)
1204     {
1205         buf_set_watermark(filebuflen/2);
1206         dsp_configure(ci.dsp, DSP_RESET, 0);
1207         playlist_update_resume_info(audio_current_track());
1208     }
1209
1210     /* Get track metadata if we don't already have it. */
1211     if (tracks[track_widx].id3_hid < 0)
1212     {
1213         tracks[track_widx].id3_hid = bufopen(trackname, 0, TYPE_ID3, NULL);
1214
1215         if (tracks[track_widx].id3_hid < 0)
1216         {
1217             /* Buffer is full. */
1218             get_metadata(&unbuffered_id3, fd, trackname);
1219             last_peek_offset--;
1220             close(fd);
1221             logf("buffer is full for now (get metadata)");
1222             filling = STATE_FULL;
1223             return false;
1224         }
1225
1226         if (track_widx == track_ridx)
1227         {
1228             /* TODO: Superfluos buffering call? */
1229             buf_request_buffer_handle(tracks[track_widx].id3_hid);
1230             if (bufreadid3(tracks[track_widx].id3_hid, thistrack_id3))
1231             {
1232                 thistrack_id3->offset = offset;
1233                 logf("audio_load_track: set offset for %s to %lX\n",
1234                      thistrack_id3->title,
1235                      offset);
1236             }
1237             else
1238                 memset(thistrack_id3, 0, sizeof(struct mp3entry));
1239         }
1240
1241         if (start_play)
1242         {
1243             playlist_update_resume_info(audio_current_track());
1244         }
1245     }
1246
1247     close(fd);
1248     track_load_started = true; /* Remember that we've started loading a track */
1249     return true;
1250 }
1251
1252 #ifdef HAVE_ALBUMART
1253 /* Load any album art for the file */
1254 static void audio_load_albumart(struct mp3entry *track_id3)
1255 {
1256     int i;
1257
1258     FOREACH_ALBUMART(i)
1259     {
1260         struct bufopen_bitmap_data user_data;
1261         int hid = ERR_HANDLE_NOT_FOUND;
1262
1263         /* albumart_slots may change during a yield of bufopen,
1264          * but that's no problem */
1265         if (tracks[track_widx].aa_hid[i] >= 0 || !albumart_slots[i].used)
1266             continue;
1267
1268         memset(&user_data, 0, sizeof(user_data));
1269         user_data.dim = &(albumart_slots[i].dim);
1270
1271         /* we can only decode jpeg for embedded AA */
1272         if (track_id3->embed_albumart && track_id3->albumart.type == AA_TYPE_JPG)
1273         {
1274             user_data.embedded_albumart = &(track_id3->albumart);
1275             hid = bufopen(track_id3->path, 0, TYPE_BITMAP, &user_data);
1276         }
1277
1278         if (hid < 0 && hid != ERR_BUFFER_FULL)
1279         {
1280             /* no embedded AA or it couldn't be loaded, try other sources */
1281             char path[MAX_PATH];
1282
1283             if (find_albumart(track_id3, path, sizeof(path),
1284                 &(albumart_slots[i].dim)))
1285             {
1286                 user_data.embedded_albumart = NULL;
1287                 hid = bufopen(path, 0, TYPE_BITMAP, &user_data);
1288             }
1289         }
1290
1291         if (hid == ERR_BUFFER_FULL)
1292         {
1293             filling = STATE_FULL;
1294             logf("buffer is full for now (get album art)");
1295         }
1296         else if (hid < 0)
1297         {
1298             logf("Album art loading failed");
1299         }
1300
1301         tracks[track_widx].aa_hid[i] = hid;
1302     }
1303 }
1304 #endif
1305
1306 /* Second part of the track loading: We now have the metadata available, so we
1307    can load the codec, the album art and finally the audio data.
1308    This is called on the audio thread after the buffering thread calls the
1309    buffering_handle_finished_callback callback. */
1310 static void audio_finish_load_track(void)
1311 {
1312     size_t file_offset = 0;
1313     size_t offset = 0;
1314     bool start_play = start_play_g;
1315
1316     track_load_started = false;
1317
1318     if (tracks[track_widx].id3_hid < 0) {
1319         logf("No metadata");
1320         return;
1321     }
1322
1323     struct mp3entry *track_id3;
1324
1325     if (track_widx == track_ridx)
1326         track_id3 = thistrack_id3;
1327     else
1328         track_id3 = bufgetid3(tracks[track_widx].id3_hid);
1329
1330     if (track_id3->length == 0 && track_id3->filesize == 0)
1331     {
1332         logf("audio_finish_load_track: invalid metadata");
1333
1334         /* Invalid metadata */
1335         bufclose(tracks[track_widx].id3_hid);
1336         tracks[track_widx].id3_hid = -1;
1337
1338         /* Skip invalid entry from playlist. */
1339         playlist_skip_entry(NULL, last_peek_offset--);
1340
1341         /* load next track */
1342         LOGFQUEUE("audio > audio Q_AUDIO_FILL_BUFFER %d", (int)start_play);
1343         queue_post(&audio_queue, Q_AUDIO_FILL_BUFFER, start_play);
1344
1345         return;
1346     }
1347     /* Try to load a cuesheet for the track */
1348     if (curr_cue)
1349     {
1350         char cuepath[MAX_PATH];
1351         if (look_for_cuesheet_file(track_id3->path, cuepath))
1352         {
1353             void *temp;
1354             tracks[track_widx].cuesheet_hid =
1355                         bufalloc(NULL, sizeof(struct cuesheet), TYPE_CUESHEET);
1356             if (tracks[track_widx].cuesheet_hid >= 0)
1357             {
1358                 bufgetdata(tracks[track_widx].cuesheet_hid,
1359                            sizeof(struct cuesheet), &temp);
1360                 struct cuesheet *cuesheet = (struct cuesheet*)temp;
1361                 if (!parse_cuesheet(cuepath, cuesheet))
1362                 {
1363                     bufclose(tracks[track_widx].cuesheet_hid);
1364                     track_id3->cuesheet = NULL;
1365                 }
1366             }
1367         }
1368     }
1369
1370 #ifdef HAVE_ALBUMART
1371     audio_load_albumart(track_id3);
1372 #endif
1373
1374     /* Load the codec. */
1375     if (!audio_loadcodec(start_play))
1376     {
1377         if (tracks[track_widx].codec_hid == ERR_BUFFER_FULL)
1378         {
1379             /* No space for codec on buffer, not an error */
1380             filling = STATE_FULL;
1381             return;
1382         }
1383
1384         /* This is an error condition, either no codec was found, or reading
1385          * the codec file failed part way through, either way, skip the track */
1386         /* FIXME: We should not use splashf from audio thread! */
1387         splashf(HZ*2, "No codec for: %s", track_id3->path);
1388         /* Skip invalid entry from playlist. */
1389         playlist_skip_entry(NULL, last_peek_offset);
1390         return;
1391     }
1392
1393     track_id3->elapsed = 0;
1394     offset = track_id3->offset;
1395     size_t resume_rewind = (global_settings.resume_rewind *
1396                             track_id3->bitrate * 1000) / 8;
1397
1398     if (offset < resume_rewind)
1399     {
1400         offset = 0;
1401     }
1402     else
1403     {
1404         offset -= resume_rewind;
1405     }
1406
1407     enum data_type type = TYPE_PACKET_AUDIO;
1408
1409     switch (track_id3->codectype) {
1410     case AFMT_MPA_L1:
1411     case AFMT_MPA_L2:
1412     case AFMT_MPA_L3:
1413         if (offset > 0) {
1414             file_offset = offset;
1415         }
1416         break;
1417
1418     case AFMT_WAVPACK:
1419         if (offset > 0) {
1420             file_offset = offset;
1421             track_id3->elapsed = track_id3->length / 2;
1422         }
1423         break;
1424
1425     case AFMT_NSF:
1426     case AFMT_SPC:
1427     case AFMT_SID:
1428         logf("Loading atomic %d",track_id3->codectype);
1429         type = TYPE_ATOMIC_AUDIO;
1430         break;
1431
1432     default:
1433         /* no special treatment needed */
1434         break;
1435     }
1436
1437     track_id3->offset = offset;
1438
1439     logf("load track: %s", track_id3->path);
1440
1441     if (file_offset > AUDIO_REBUFFER_GUESS_SIZE)
1442         file_offset -= AUDIO_REBUFFER_GUESS_SIZE;
1443     else if (track_id3->first_frame_offset)
1444         file_offset = track_id3->first_frame_offset;
1445     else
1446         file_offset = 0;
1447
1448     tracks[track_widx].audio_hid = bufopen(track_id3->path, file_offset, type,
1449                                             NULL);
1450
1451     /* No space left, not an error */
1452     if (tracks[track_widx].audio_hid == ERR_BUFFER_FULL)
1453     {
1454         filling = STATE_FULL;
1455         logf("buffer is full for now (load audio)");
1456         return;
1457     }
1458     else if (tracks[track_widx].audio_hid < 0)
1459     {
1460         /* another error, do not continue either */
1461         logf("Could not add audio data handle");
1462         return;
1463     }
1464
1465     /* All required data is now available for the codec -- unless the
1466        autoresume feature is in effect.  In the latter case, the codec
1467        must wait until after PLAYBACK_EVENT_TRACK_BUFFER, which may
1468        generate a resume position.  */
1469 #ifdef HAVE_TAGCACHE
1470     if (! global_settings.autoresume_enable)
1471 #endif
1472         tracks[track_widx].taginfo_ready = true;
1473
1474     if (start_play)
1475     {
1476         ci.curpos=file_offset;
1477         buf_request_buffer_handle(tracks[track_widx].audio_hid);
1478     }
1479
1480     send_event(PLAYBACK_EVENT_TRACK_BUFFER, track_id3);
1481
1482 #ifdef HAVE_TAGCACHE
1483     /* In case the autoresume feature has been enabled, finally all
1484        required data is available for the codec. */
1485     if (global_settings.autoresume_enable)
1486         tracks[track_widx].taginfo_ready = true;
1487 #endif
1488
1489     track_widx = (track_widx + 1) & MAX_TRACK_MASK;
1490
1491     /* load next track */
1492     LOGFQUEUE("audio > audio Q_AUDIO_FILL_BUFFER");
1493     queue_post(&audio_queue, Q_AUDIO_FILL_BUFFER, 0);
1494
1495     return;
1496 }
1497
1498 static void audio_fill_file_buffer(bool start_play, size_t offset)
1499 {
1500     trigger_cpu_boost();
1501
1502     /* No need to rebuffer if there are track skips pending,
1503      * however don't cancel buffering on skipping while filling. */
1504     if (ci.new_track != 0 && filling != STATE_FILLING)
1505         return;
1506     filling = STATE_FILLING;
1507
1508     /* Must reset the buffer before use if trashed or voice only - voice
1509        file size shouldn't have changed so we can go straight from
1510        AUDIOBUF_STATE_VOICED_ONLY to AUDIOBUF_STATE_INITIALIZED */
1511     if (buffer_state != AUDIOBUF_STATE_INITIALIZED)
1512         audio_reset_buffer();
1513
1514     logf("Starting buffer fill");
1515
1516     if (!start_play)
1517         audio_clear_track_entries();
1518
1519     /* Save the current resume position once. */
1520     playlist_update_resume_info(audio_current_track());
1521
1522     audio_load_track(offset, start_play);
1523 }
1524
1525 static void audio_rebuffer(void)
1526 {
1527     logf("Forcing rebuffer");
1528
1529     clear_track_info(CUR_TI);
1530
1531     /* Reset track pointers */
1532     track_widx = track_ridx;
1533     audio_clear_track_entries();
1534
1535     /* Reset a possibly interrupted track load */
1536     track_load_started = false;
1537
1538     /* Fill the buffer */
1539     last_peek_offset = -1;
1540     ci.curpos = 0;
1541
1542     if (!CUR_TI->taginfo_ready)
1543         memset(thistrack_id3, 0, sizeof(struct mp3entry));
1544
1545     audio_fill_file_buffer(false, 0);
1546 }
1547
1548 /* Called on request from the codec to get a new track. This is the codec part
1549    of the track transition. */
1550 static void audio_last_track(bool automatic)
1551 {
1552     if (automatic)
1553     {
1554         ci.new_track = 0;
1555         automatic_skip = false;
1556
1557         if (filling != STATE_ENDING)
1558         {
1559             /* Monitor remaining PCM before stopping */
1560             filling = STATE_ENDING;
1561             pcmbuf_monitor_track_change(true);
1562         }
1563
1564         codec_stop();
1565     }
1566     else
1567     {
1568         audio_stop_playback();
1569     }
1570 }
1571
1572 static void audio_check_new_track(void)
1573 {
1574     int track_count;
1575     int old_track_ridx;
1576     int i, idx;
1577     bool forward;
1578     struct mp3entry *temp;
1579
1580     if (ci.new_track == 0)
1581     {
1582         ci.new_track++;
1583         automatic_skip = true;
1584     }
1585
1586     track_count = audio_track_count();
1587     old_track_ridx = track_ridx;
1588
1589     /* Now it's good time to send track finish events. */
1590     send_event(PLAYBACK_EVENT_TRACK_FINISH, thistrack_id3);
1591     /* swap the mp3entry pointers */
1592     temp = thistrack_id3;
1593     thistrack_id3 = othertrack_id3;
1594     othertrack_id3 = temp;
1595     ci.id3 = thistrack_id3;
1596     memset(thistrack_id3, 0, sizeof(struct mp3entry));
1597
1598     if (dir_skip)
1599     {
1600         dir_skip = false;
1601         /* regardless of the return value we need to rebuffer.
1602            if it fails the old playlist will resume, else the
1603            next dir will start playing */
1604         playlist_next_dir(ci.new_track);
1605         ci.new_track = 0;
1606         audio_rebuffer();
1607         goto skip_done;
1608     }
1609
1610     if (new_playlist)
1611         ci.new_track = 0;
1612
1613     /* If the playlist isn't that big */
1614     if (automatic_skip)
1615     {
1616         while (!playlist_check(ci.new_track))
1617         {
1618             if (ci.new_track >= 0)
1619             {
1620                 audio_last_track(true);
1621                 return;
1622             }
1623             ci.new_track++;
1624         }
1625     }
1626
1627     /* Update the playlist */
1628     last_peek_offset -= ci.new_track;
1629
1630     if (playlist_next(ci.new_track) < 0)
1631     {
1632         /* End of list */
1633         audio_last_track(automatic_skip);
1634         return;
1635     }
1636
1637     if (new_playlist)
1638     {
1639         ci.new_track = 1;
1640         new_playlist = false;
1641     }
1642
1643     /* Save a pointer to the old track to allow later clearing */
1644     prev_ti = CUR_TI;
1645
1646     for (i = 0; i < ci.new_track; i++)
1647     {
1648         idx = (track_ridx + i) & MAX_TRACK_MASK;
1649         struct mp3entry *id3 = bufgetid3(tracks[idx].id3_hid);
1650         ssize_t offset = buf_handle_offset(tracks[idx].audio_hid);
1651         if (!id3 || offset < 0 || (unsigned)offset > id3->first_frame_offset)
1652         {
1653             /* We don't have all the audio data for that track, so clear it,
1654                but keep the metadata. */
1655             if (tracks[idx].audio_hid >= 0 && bufclose(tracks[idx].audio_hid))
1656             {
1657                 tracks[idx].audio_hid = -1;
1658                 tracks[idx].filesize = 0;
1659             }
1660         }
1661     }
1662
1663     /* Move to the new track */
1664     track_ridx = (track_ridx + ci.new_track) & MAX_TRACK_MASK;
1665     buf_set_base_handle(CUR_TI->audio_hid);
1666
1667     if (automatic_skip)
1668     {
1669         wps_offset = -ci.new_track;
1670     }
1671
1672     /* If it is not safe to even skip this many track entries */
1673     if (ci.new_track >= track_count || ci.new_track <= track_count - MAX_TRACK)
1674     {
1675         ci.new_track = 0;
1676         audio_rebuffer();
1677         goto skip_done;
1678     }
1679
1680     forward = ci.new_track > 0;
1681     ci.new_track = 0;
1682
1683     /* If the target track is clearly not in memory */
1684     if (CUR_TI->filesize == 0 || !CUR_TI->taginfo_ready)
1685     {
1686         audio_rebuffer();
1687         goto skip_done;
1688     }
1689
1690     /* When skipping backwards, it is possible that we've found a track that's
1691      * buffered, but which is around the track-wrap and therefore not the track
1692      * we are looking for */
1693     if (!forward)
1694     {
1695         int cur_idx = track_ridx;
1696         bool taginfo_ready = true;
1697         /* We've wrapped the buffer backwards if new > old */
1698         bool wrap = track_ridx > old_track_ridx;
1699
1700         while (1)
1701         {
1702             cur_idx = (cur_idx + 1) & MAX_TRACK_MASK;
1703
1704             /* if we've advanced past the wrap when cur_idx is zeroed */
1705             if (!cur_idx)
1706                 wrap = false;
1707
1708             /* if we aren't still on the wrap and we've caught the old track */
1709             if (!(wrap || cur_idx < old_track_ridx))
1710                 break;
1711
1712             /* If we hit a track in between without valid tag info, bail */
1713             if (!tracks[cur_idx].taginfo_ready)
1714             {
1715                 taginfo_ready = false;
1716                 break;
1717             }
1718         }
1719         if (!taginfo_ready)
1720         {
1721             audio_rebuffer();
1722         }
1723     }
1724
1725 skip_done:
1726     audio_update_trackinfo();
1727     pcmbuf_start_track_change(automatic_skip);
1728
1729     if (get_codec_base_type(codec_loaded()) ==
1730         get_codec_base_type(thistrack_id3->codectype))
1731     {
1732         /* codec is the same base type */
1733         logf("New track loaded");
1734         codec_ack_msg(Q_CODEC_REQUEST_COMPLETE, false);
1735     }
1736     else
1737     {
1738         /* a codec change is required */
1739         logf("New codec: %d/%d", thistrack_id3->codectype, codec_loaded());
1740         codec_ack_msg(Q_CODEC_REQUEST_COMPLETE, true);
1741         codec_load(tracks[track_ridx].codec_hid, thistrack_id3->codectype);
1742         tracks[track_ridx].codec_hid = -1; /* Codec thread will close it */
1743     }
1744 }
1745
1746 unsigned long audio_prev_elapsed(void)
1747 {
1748     return prev_track_elapsed;
1749 }
1750
1751 void audio_set_prev_elapsed(unsigned long setting)
1752 {
1753     prev_track_elapsed = setting;
1754 }
1755
1756 /* Stop the codec and reset the PCM buffer */
1757 static void audio_stop_codec_flush(void)
1758 {
1759     bool pcm_playing;
1760
1761     pcmbuf_pause(true);
1762
1763     codec_stop();
1764
1765     pcm_play_lock();
1766
1767     pcm_playing = pcm_is_playing();
1768
1769     pcmbuf_play_stop();
1770     queue_clear(&pcmbuf_queue);
1771
1772     if (pcm_playing)
1773         pcmbuf_pause(paused);
1774
1775     pcm_play_unlock();
1776 }
1777
1778 static void audio_stop_playback(void)
1779 {
1780     if (playing)
1781     {
1782         /* If we were playing, save resume information */
1783         struct mp3entry *id3 = NULL;
1784
1785         if (!ci.stop_codec)
1786             id3 = audio_current_track();
1787
1788         /* Save the current playing spot, or NULL if the playlist has ended */
1789         playlist_update_resume_info(id3);
1790
1791         /* Now it's good time to send track finish events.  Do this
1792            only if this hasn't been done already as part of a track
1793            switch. */
1794         if (id3 == thistrack_id3)
1795             send_event(PLAYBACK_EVENT_TRACK_FINISH, thistrack_id3);
1796
1797         /* TODO: Create auto bookmark too? */
1798
1799         prev_track_elapsed = othertrack_id3->elapsed;
1800
1801         remove_event(BUFFER_EVENT_BUFFER_LOW, buffering_low_buffer_callback);
1802     }
1803
1804     audio_stop_codec_flush();
1805     paused = false;
1806     playing = false;
1807     track_load_started = false;
1808
1809     filling = STATE_IDLE;
1810
1811     /* Mark all entries null. */
1812     audio_clear_track_entries();
1813
1814     /* Close all tracks */
1815     audio_release_tracks();
1816 }
1817
1818 static void audio_play_start(size_t offset)
1819 {
1820     int i;
1821
1822     send_event(PLAYBACK_EVENT_START_PLAYBACK, NULL);
1823 #if INPUT_SRC_CAPS != 0
1824     audio_set_input_source(AUDIO_SRC_PLAYBACK, SRCF_PLAYBACK);
1825     audio_set_output_source(AUDIO_SRC_PLAYBACK);
1826 #endif
1827
1828     paused = false;
1829     audio_stop_codec_flush();
1830
1831     playing = true;
1832     track_load_started = false;
1833
1834     ci.new_track = 0;
1835     ci.seek_time = 0;
1836     wps_offset = 0;
1837
1838     sound_set_volume(global_settings.volume);
1839     track_widx = track_ridx = 0;
1840     buf_set_base_handle(-1);
1841
1842     /* Clear all track entries. */
1843     for (i = 0; i < MAX_TRACK; i++) {
1844         clear_track_info(&tracks[i]);
1845     }
1846
1847     last_peek_offset = -1;
1848
1849     /* Officially playing */
1850     queue_reply(&audio_queue, 1);
1851
1852     audio_fill_file_buffer(true, offset);
1853
1854     add_event(BUFFER_EVENT_BUFFER_LOW, false, buffering_low_buffer_callback);
1855
1856     LOGFQUEUE("audio > audio Q_AUDIO_TRACK_CHANGED");
1857     queue_post(&audio_queue, Q_AUDIO_TRACK_CHANGED, 0);
1858 }
1859
1860
1861 /* Invalidates all but currently playing track. */
1862 static void audio_invalidate_tracks(void)
1863 {
1864     if (audio_have_tracks())
1865     {
1866         last_peek_offset = 0;
1867         track_widx = track_ridx;
1868
1869         /* Mark all other entries null (also buffered wrong metadata). */
1870         audio_clear_track_entries();
1871
1872         track_widx = (track_widx + 1) & MAX_TRACK_MASK;
1873
1874         audio_fill_file_buffer(false, 0);
1875         send_event(PLAYBACK_EVENT_TRACK_CHANGE, thistrack_id3);
1876     }
1877 }
1878
1879 static void audio_new_playlist(void)
1880 {
1881     /* Prepare to start a new fill from the beginning of the playlist */
1882     last_peek_offset = -1;
1883
1884     /* Signal the codec to initiate a track change forward */
1885     new_playlist = true;
1886     ci.new_track = 1;
1887
1888     if (audio_have_tracks())
1889     {
1890         if (paused)
1891             skipped_during_pause = true;
1892         track_widx = track_ridx;
1893         audio_clear_track_entries();
1894
1895         track_widx = (track_widx + 1) & MAX_TRACK_MASK;
1896
1897         /* Mark the current track as invalid to prevent skipping back to it */
1898         CUR_TI->taginfo_ready = false;
1899     }
1900
1901     /* Officially playing */
1902     queue_reply(&audio_queue, 1);
1903
1904     audio_fill_file_buffer(false, 0);
1905 }
1906
1907 /* Called on manual track skip */
1908 static void audio_initiate_track_change(long direction)
1909 {
1910     logf("audio_initiate_track_change(%ld)", direction);
1911
1912     ci.new_track += direction;
1913     wps_offset -= direction;
1914     if (paused)
1915         skipped_during_pause = true;
1916 }
1917
1918 /* Called on manual dir skip */
1919 static void audio_initiate_dir_change(long direction)
1920 {
1921     dir_skip = true;
1922     ci.new_track = direction;
1923     if (paused)
1924         skipped_during_pause = true;
1925 }
1926
1927 /* Called when PCM track change is complete */
1928 static void audio_finalise_track_change(void)
1929 {
1930     logf("audio_finalise_track_change");
1931
1932     if (automatic_skip)
1933     {
1934         wps_offset = 0;
1935         automatic_skip = false;
1936
1937         /* Invalidate prevtrack_id3 */
1938         memset(othertrack_id3, 0, sizeof(struct mp3entry));
1939
1940         if (prev_ti && prev_ti->audio_hid < 0)
1941         {
1942             /* No audio left so we clear all the track info. */
1943             clear_track_info(prev_ti);
1944         }
1945     }
1946     send_event(PLAYBACK_EVENT_TRACK_CHANGE, thistrack_id3);
1947     playlist_update_resume_info(audio_current_track());
1948 }
1949
1950 static void audio_seek_complete(void)
1951 {
1952     logf("audio_seek_complete");
1953
1954     if (!playing)
1955         return;
1956
1957     /* If seeking-while-playing, pcm_is_paused() is true.
1958      * If seeking-while-paused, audio_status PAUSE is true.
1959      * A seamless seek skips this section. */
1960     ci.seek_time = 0;
1961
1962     pcm_play_lock();
1963
1964     if (pcm_is_paused() || paused)
1965     {
1966         /* Clear the buffer */
1967         pcmbuf_play_stop();
1968
1969         /* If seeking-while-playing, resume PCM playback */
1970         if (!paused)
1971             pcmbuf_pause(false);
1972     }
1973
1974     pcm_play_unlock();
1975 }
1976
1977 static void audio_codec_status_message(long reason, int status)
1978 {
1979     /* TODO: Push the errors up to the normal UI somewhere */
1980     switch (reason)
1981     {
1982     case Q_CODEC_LOAD_DISK:
1983     case Q_CODEC_LOAD:
1984         if (!playing)
1985             return;
1986
1987         if (status < 0)
1988         {
1989             splash(HZ*2, "Codec failure");
1990             audio_check_new_track();
1991         }
1992         break;
1993
1994 #ifdef AUDIO_HAVE_RECORDING
1995     case Q_ENCODER_LOAD_DISK:
1996         if (status < 0)
1997             splash(HZ*2, "Encoder failure");
1998         break;
1999 #endif /* AUDIO_HAVE_RECORDING */
2000     }
2001 }
2002
2003 /*
2004  * Layout audio buffer as follows - iram buffer depends on target:
2005  * [|SWAP:iram][|TALK]|FILE|GUARD|PCM|[SWAP:dram[|iram]|]
2006  */
2007 static void audio_reset_buffer(void)
2008 {
2009     /* see audio_get_recording_buffer if this is modified */
2010     logf("audio_reset_buffer");
2011
2012     /* If the setup of anything allocated before the file buffer is
2013        changed, do check the adjustments after the buffer_alloc call
2014        as it will likely be affected and need sliding over */
2015
2016     /* Initially set up file buffer as all space available */
2017     malloc_buf = audiobuf + talk_get_bufsize();
2018
2019     /* Align the malloc buf to line size.
2020      * Especially important to cf targets that do line reads/writes.
2021      * Also for targets which need aligned DMA storage buffers */
2022     malloc_buf = (unsigned char *)(((uintptr_t)malloc_buf + (CACHEALIGN_SIZE - 1)) & ~(CACHEALIGN_SIZE - 1));
2023     filebuf    = malloc_buf; /* filebuf line align implied */
2024     filebuflen = (audiobufend - filebuf) & ~(CACHEALIGN_SIZE - 1);
2025
2026     /* Subtract whatever the pcm buffer says it used plus the guard buffer */
2027     const size_t pcmbuf_size = pcmbuf_init(filebuf + filebuflen) +GUARD_BUFSIZE;
2028     if(pcmbuf_size > filebuflen)
2029         panicf("%s(): EOM (%zu > %zu)", __func__, pcmbuf_size, filebuflen);
2030
2031     filebuflen -= pcmbuf_size;
2032
2033     /* Make sure filebuflen is a longword multiple after adjustment - filebuf
2034        will already be line aligned */
2035     filebuflen &= ~3;
2036
2037     buffering_reset(filebuf, filebuflen);
2038
2039     /* Clear any references to the file buffer */
2040     buffer_state = AUDIOBUF_STATE_INITIALIZED;
2041
2042 #if defined(ROCKBOX_HAS_LOGF) && defined(LOGF_ENABLE)
2043     /* Make sure everything adds up - yes, some info is a bit redundant but
2044        aids viewing and the sumation of certain variables should add up to
2045        the location of others. */
2046     {
2047         size_t pcmbufsize;
2048         const unsigned char *pcmbuf = pcmbuf_get_meminfo(&pcmbufsize);
2049         logf("mabuf:  %08X", (unsigned)malloc_buf);
2050         logf("fbuf:   %08X", (unsigned)filebuf);
2051         logf("fbufe:  %08X", (unsigned)(filebuf + filebuflen));
2052         logf("gbuf:   %08X", (unsigned)(filebuf + filebuflen));
2053         logf("gbufe:  %08X", (unsigned)(filebuf + filebuflen + GUARD_BUFSIZE));
2054         logf("pcmb:   %08X", (unsigned)pcmbuf);
2055         logf("pcmbe:  %08X", (unsigned)(pcmbuf + pcmbufsize));
2056     }
2057 #endif
2058 }
2059
2060 static void audio_thread(void)
2061 {
2062     struct queue_event ev;
2063
2064     pcm_postinit();
2065
2066     audio_thread_ready = true;
2067
2068     while (1)
2069     {
2070         switch (filling) {
2071             case STATE_IDLE:
2072                 queue_wait(&audio_queue, &ev);
2073                 break;
2074
2075 #if (CONFIG_PLATFORM & PLATFORM_NATIVE)
2076             case STATE_USB:
2077                 queue_wait(&audio_queue, &ev);
2078                 switch (ev.id) {
2079 #ifdef AUDIO_HAVE_RECORDING
2080                     /* Must monitor the encoder message for recording so it can
2081                        remove it if we process the insertion before it does. It
2082                        cannot simply be removed from under recording however. */
2083                     case Q_AUDIO_LOAD_ENCODER:
2084                         break;
2085 #endif
2086                     case SYS_USB_DISCONNECTED:
2087                         filling = STATE_IDLE;
2088                     default:
2089                         continue;
2090                 }
2091                 break;
2092 #endif /* CONFIG_PLATFORM */
2093
2094             default:
2095                 /* End of buffering, let's calculate the watermark and
2096                    unboost */
2097                 set_filebuf_watermark();
2098                 cancel_cpu_boost();
2099                 /* Fall-through */
2100             case STATE_FILLING:
2101             case STATE_ENDING:
2102                 if (!pcmbuf_queue_scan(&ev))
2103                     queue_wait_w_tmo(&audio_queue, &ev, HZ/2);
2104                 break;
2105         }
2106
2107         switch (ev.id) {
2108
2109             case Q_AUDIO_FILL_BUFFER:
2110                 LOGFQUEUE("audio < Q_AUDIO_FILL_BUFFER %d", (int)ev.data);
2111                 audio_fill_file_buffer((bool)ev.data, 0);
2112                 break;
2113
2114             case Q_AUDIO_FINISH_LOAD:
2115                 LOGFQUEUE("audio < Q_AUDIO_FINISH_LOAD");
2116                 audio_finish_load_track();
2117                 buf_set_base_handle(CUR_TI->audio_hid);
2118                 break;
2119
2120             case Q_AUDIO_PLAY:
2121                 LOGFQUEUE("audio < Q_AUDIO_PLAY");
2122                 if (playing && ev.data <= 0)
2123                     audio_new_playlist();
2124                 else
2125                 {
2126                     audio_stop_playback();
2127                     audio_play_start((size_t)ev.data);
2128                 }
2129                 break;
2130
2131             case Q_AUDIO_STOP:
2132                 LOGFQUEUE("audio < Q_AUDIO_STOP");
2133                 if (playing)
2134                     audio_stop_playback();
2135                 if (ev.data != 0)
2136                     queue_clear(&audio_queue);
2137                 break;
2138
2139             case Q_AUDIO_PAUSE:
2140                 LOGFQUEUE("audio < Q_AUDIO_PAUSE");
2141                 if (!(bool) ev.data && skipped_during_pause
2142 #ifdef HAVE_CROSSFADE
2143                     && !pcmbuf_is_crossfade_active()
2144 #endif
2145                     )
2146                     pcmbuf_play_stop(); /* Flush old track on resume after skip */
2147                 skipped_during_pause = false;
2148                 if (!playing)
2149                     break;
2150                 pcmbuf_pause((bool)ev.data);
2151                 paused = (bool)ev.data;
2152                 break;
2153
2154             case Q_AUDIO_SKIP:
2155                 LOGFQUEUE("audio < Q_AUDIO_SKIP");
2156                 audio_initiate_track_change((long)ev.data);
2157                 break;
2158
2159             case Q_AUDIO_PRE_FF_REWIND:
2160                 LOGFQUEUE("audio < Q_AUDIO_PRE_FF_REWIND");
2161                 if (!playing)
2162                     break;
2163                 pcmbuf_pause(true);
2164                 break;
2165
2166             case Q_AUDIO_FF_REWIND:
2167                 LOGFQUEUE("audio < Q_AUDIO_FF_REWIND");
2168                 if (!playing)
2169                     break;
2170
2171                 if (filling == STATE_ENDING)
2172                 {
2173                     /* Temp workaround: There is no codec available */
2174                     if (!paused)
2175                         pcmbuf_pause(false);
2176                     break;
2177                 }
2178
2179                 if ((long)ev.data == 0)
2180                 {
2181                     /* About to restart the track - send track finish
2182                        events if not already done. */
2183                     if (thistrack_id3 == audio_current_track())
2184                         send_event(PLAYBACK_EVENT_TRACK_FINISH, thistrack_id3);
2185                 }
2186
2187                 if (automatic_skip)
2188                 {
2189                     /* An automatic track skip is in progress. Finalize it,
2190                        then go back to the previous track */
2191                     audio_finalise_track_change();
2192                     ci.new_track = -1;
2193                 }
2194                 ci.seek_time = (long)ev.data+1;
2195                 break;
2196
2197             case Q_AUDIO_CHECK_NEW_TRACK:
2198                 LOGFQUEUE("audio < Q_AUDIO_CHECK_NEW_TRACK");
2199                 audio_check_new_track();
2200                 break;
2201
2202             case Q_AUDIO_DIR_SKIP:
2203                 LOGFQUEUE("audio < Q_AUDIO_DIR_SKIP");
2204                 audio_initiate_dir_change(ev.data);
2205                 break;
2206
2207             case Q_AUDIO_FLUSH:
2208                 LOGFQUEUE("audio < Q_AUDIO_FLUSH");
2209                 audio_invalidate_tracks();
2210                 break;
2211
2212             case Q_AUDIO_TRACK_CHANGED:
2213                 /* PCM track change done */
2214                 LOGFQUEUE("audio < Q_AUDIO_TRACK_CHANGED");
2215                 if (filling != STATE_ENDING)
2216                     audio_finalise_track_change();
2217                 else if (playing)
2218                     audio_stop_playback();
2219                 break;
2220
2221             case Q_AUDIO_SEEK_COMPLETE:
2222                 /* Codec seek done */
2223                 LOGFQUEUE("audio < Q_AUDIO_SEEK_COMPLETE");
2224                 audio_seek_complete();
2225                 codec_ack_msg(Q_AUDIO_SEEK_COMPLETE, false);
2226                 break;
2227
2228             case Q_CODEC_LOAD:
2229             case Q_CODEC_LOAD_DISK:
2230 #ifdef AUDIO_HAVE_RECORDING
2231             case Q_ENCODER_LOAD_DISK:
2232 #endif
2233                 /* These are received when a codec has finished normally or
2234                    upon a codec error */
2235                 audio_codec_status_message(ev.id, ev.data);
2236                 break;
2237
2238 #if (CONFIG_PLATFORM & PLATFORM_NATIVE)
2239             case SYS_USB_CONNECTED:
2240                 LOGFQUEUE("audio < SYS_USB_CONNECTED");
2241                 if (playing)
2242                     audio_stop_playback();
2243 #ifdef PLAYBACK_VOICE
2244                 voice_stop();
2245 #endif
2246                 filling = STATE_USB;
2247                 usb_acknowledge(SYS_USB_CONNECTED_ACK);
2248                 break;
2249 #endif
2250
2251 #ifdef AUDIO_HAVE_RECORDING
2252             case Q_AUDIO_LOAD_ENCODER:
2253                 if (playing)
2254                     audio_stop_playback();
2255                 else
2256                     codec_stop(); /* If encoder still loaded, stop it */
2257
2258                 if (ev.data == AFMT_UNKNOWN)
2259                     break;
2260
2261                 queue_reply(&audio_queue,
2262                             codec_load(-1, ev.data | CODEC_TYPE_ENCODER));
2263                 break;
2264 #endif /* AUDIO_HAVE_RECORDING */
2265
2266             case SYS_TIMEOUT:
2267                 LOGFQUEUE_SYS_TIMEOUT("audio < SYS_TIMEOUT");
2268                 break;
2269
2270             default:
2271                 /* LOGFQUEUE("audio < default : %08lX", ev.id); */
2272                 break;
2273         } /* end switch */
2274     } /* end while */
2275 }
2276
2277 /* Initialize the audio system - called from init() in main.c.
2278  * Last function because of all the references to internal symbols
2279  */
2280 void audio_init(void)
2281 {
2282     unsigned int audio_thread_id;
2283
2284     /* Can never do this twice */
2285     if (audio_is_initialized)
2286     {
2287         logf("audio: already initialized");
2288         return;
2289     }
2290
2291     logf("audio: initializing");
2292
2293     /* Initialize queues before giving control elsewhere in case it likes
2294        to send messages. Thread creation will be delayed however so nothing
2295        starts running until ready if something yields such as talk_init. */
2296     queue_init(&audio_queue, true);
2297     queue_init(&pcmbuf_queue, false);
2298
2299     pcm_init();
2300
2301     codec_init_codec_api();
2302
2303     thistrack_id3 = &mp3entry_buf[0];
2304     othertrack_id3 = &mp3entry_buf[1];
2305
2306     /* cuesheet support */
2307     if (global_settings.cuesheet)
2308         curr_cue = (struct cuesheet*)buffer_alloc(sizeof(struct cuesheet));
2309
2310     /* initialize the buffer */
2311     filebuf = audiobuf;
2312
2313     /* audio_reset_buffer must to know the size of voice buffer so init
2314        talk first */
2315     talk_init();
2316
2317     make_codec_thread();
2318
2319     audio_thread_id = create_thread(audio_thread, audio_stack,
2320                   sizeof(audio_stack), CREATE_THREAD_FROZEN,
2321                   audio_thread_name IF_PRIO(, PRIORITY_USER_INTERFACE)
2322                   IF_COP(, CPU));
2323
2324     queue_enable_queue_send(&audio_queue, &audio_queue_sender_list,
2325                             audio_thread_id);
2326
2327 #ifdef PLAYBACK_VOICE
2328     voice_thread_init();
2329 #endif
2330
2331 #ifdef HAVE_CROSSFADE
2332     /* Set crossfade setting for next buffer init which should be about... */
2333     pcmbuf_request_crossfade_enable(global_settings.crossfade);
2334 #endif
2335
2336     /* initialize the buffering system */
2337
2338     buffering_init();
2339     /* ...now! Set up the buffers */
2340     audio_reset_buffer();
2341
2342     int i;
2343     for(i = 0; i < MAX_TRACK; i++)
2344     {
2345         tracks[i].audio_hid = -1;
2346         tracks[i].id3_hid = -1;
2347         tracks[i].codec_hid = -1;
2348         tracks[i].cuesheet_hid = -1;
2349     }
2350 #ifdef HAVE_ALBUMART
2351     FOREACH_ALBUMART(i)
2352     {
2353         int j;
2354         for (j = 0; j < MAX_TRACK; j++)
2355         {
2356             tracks[j].aa_hid[i] = -1;
2357         }
2358     }
2359 #endif
2360
2361     add_event(BUFFER_EVENT_REBUFFER, false, buffering_handle_rebuffer_callback);
2362     add_event(BUFFER_EVENT_FINISHED, false, buffering_handle_finished_callback);
2363
2364     /* Probably safe to say */
2365     audio_is_initialized = true;
2366
2367     sound_settings_apply();
2368 #ifdef HAVE_DISK_STORAGE
2369     audio_set_buffer_margin(global_settings.buffer_margin);
2370 #endif
2371
2372     /* it's safe to let the threads run now */
2373 #ifdef PLAYBACK_VOICE
2374     voice_thread_resume();
2375 #endif
2376     codec_thread_resume();
2377     thread_thaw(audio_thread_id);
2378
2379 } /* audio_init */
2380
2381 bool audio_is_thread_ready(void)
2382 {
2383     return audio_thread_ready;
2384 }
2385
2386 size_t audio_get_filebuflen(void)
2387 {
2388     return filebuflen;
2389 }
2390
2391 int get_audio_hid()
2392 {
2393     return CUR_TI->audio_hid;
2394 }