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