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 bool audio_peek_track(struct mp3entry* id3, int offset)
 633 {
 634     int next_idx;
 635     int new_offset = ci.new_track + wps_offset + offset;
 636
 637     if (!audio_have_tracks())
 638         return false;
 639     next_idx = (track_ridx + new_offset) & MAX_TRACK_MASK;
 640
 641     if (tracks[next_idx].id3_hid >= 0)
 642     {
 643         return bufread(tracks[next_idx].id3_hid, sizeof(struct mp3entry), id3)
 644                     == sizeof(struct mp3entry);
 645     }
 646     return false;
 647 }
 648
 649 #ifdef HAVE_ALBUMART
 650 int playback_current_aa_hid(int slot)
 651 {
 652     if (slot < 0)
 653         return -1;
 654     int cur_idx;
 655     int offset = ci.new_track + wps_offset;
 656
 657     cur_idx = track_ridx + offset;
 658     cur_idx &= MAX_TRACK_MASK;
 659
 660     return tracks[cur_idx].aa_hid[slot];
 661 }
 662
 663 int playback_claim_aa_slot(struct dim *dim)
 664 {
 665     int i;
 666     /* first try to find a slot already having the size to reuse it
 667      * since we don't want albumart of the same size buffered multiple times */
 668     FOREACH_ALBUMART(i)
 669     {
 670         struct albumart_slot *slot = &albumart_slots[i];
 671         if (slot->dim.width == dim->width
 672                 && slot->dim.height == dim->height)
 673         {
 674             slot->used++;
 675             return i;
 676         }
 677     }
 678     /* size is new, find a free slot */
 679     FOREACH_ALBUMART(i)
 680     {
 681         if (!albumart_slots[i].used)
 682         {
 683             albumart_slots[i].used++;
 684             albumart_slots[i].dim = *dim;
 685             return i;
 686         }
 687     }
 688     /* sorry, no free slot */
 689     return -1;
 690 }
 691
 692 void playback_release_aa_slot(int slot)
 693 {
 694     /* invalidate the albumart_slot */
 695     struct albumart_slot *aa_slot = &albumart_slots[slot];
 696     if (aa_slot->used > 0)
 697         aa_slot->used--;
 698 }
 699
 700 #endif
 701 void audio_play(long offset)
 702 {
 703     logf("audio_play");
 704
 705 #ifdef PLAYBACK_VOICE
 706     /* Truncate any existing voice output so we don't have spelling
 707      * etc. over the first part of the played track */
 708     talk_force_shutup();
 709 #endif
 710
 711     /* Start playback */
 712     LOGFQUEUE("audio >| audio Q_AUDIO_PLAY: %ld", offset);
 713     /* Don't return until playback has actually started */
 714     queue_send(&audio_queue, Q_AUDIO_PLAY, offset);
 715 }
 716
 717 void audio_stop(void)
 718 {
 719     /* Stop playback */
 720     LOGFQUEUE("audio >| audio Q_AUDIO_STOP");
 721     /* Don't return until playback has actually stopped */
 722     queue_send(&audio_queue, Q_AUDIO_STOP, 0);
 723 }
 724
 725 void audio_pause(void)
 726 {
 727     LOGFQUEUE("audio >| audio Q_AUDIO_PAUSE");
 728     /* Don't return until playback has actually paused */
 729     queue_send(&audio_queue, Q_AUDIO_PAUSE, true);
 730 }
 731
 732 void audio_resume(void)
 733 {
 734     LOGFQUEUE("audio >| audio Q_AUDIO_PAUSE resume");
 735     /* Don't return until playback has actually resumed */
 736     queue_send(&audio_queue, Q_AUDIO_PAUSE, false);
 737 }
 738
 739 void audio_skip(int direction)
 740 {
 741     if (playlist_check(ci.new_track + wps_offset + direction))
 742     {
 743         if (global_settings.beep)
 744             pcmbuf_beep(2000, 100, 2500*global_settings.beep);
 745
 746         LOGFQUEUE("audio > audio Q_AUDIO_SKIP %d", direction);
 747         queue_post(&audio_queue, Q_AUDIO_SKIP, direction);
 748         /* Update wps while our message travels inside deep playback queues. */
 749         wps_offset += direction;
 750     }
 751     else
 752     {
 753         /* No more tracks. */
 754         if (global_settings.beep)
 755             pcmbuf_beep(1000, 100, 1500*global_settings.beep);
 756     }
 757 }
 758
 759 void audio_next(void)
 760 {
 761     audio_skip(1);
 762 }
 763
 764 void audio_prev(void)
 765 {
 766     audio_skip(-1);
 767 }
 768
 769 void audio_next_dir(void)
 770 {
 771     LOGFQUEUE("audio > audio Q_AUDIO_DIR_SKIP 1");
 772     queue_post(&audio_queue, Q_AUDIO_DIR_SKIP, 1);
 773 }
 774
 775 void audio_prev_dir(void)
 776 {
 777     LOGFQUEUE("audio > audio Q_AUDIO_DIR_SKIP -1");
 778     queue_post(&audio_queue, Q_AUDIO_DIR_SKIP, -1);
 779 }
 780
 781 void audio_pre_ff_rewind(void)
 782 {
 783     LOGFQUEUE("audio > audio Q_AUDIO_PRE_FF_REWIND");
 784     queue_post(&audio_queue, Q_AUDIO_PRE_FF_REWIND, 0);
 785 }
 786
 787 void audio_ff_rewind(long newpos)
 788 {
 789     LOGFQUEUE("audio > audio Q_AUDIO_FF_REWIND");
 790     queue_post(&audio_queue, Q_AUDIO_FF_REWIND, newpos);
 791 }
 792
 793 void audio_flush_and_reload_tracks(void)
 794 {
 795     LOGFQUEUE("audio > audio Q_AUDIO_FLUSH");
 796     queue_post(&audio_queue, Q_AUDIO_FLUSH, 0);
 797 }
 798
 799 void audio_error_clear(void)
 800 {
 801 #ifdef AUDIO_HAVE_RECORDING
 802     pcm_rec_error_clear();
 803 #endif
 804 }
 805
 806 int audio_status(void)
 807 {
 808     int ret = 0;
 809
 810     if (playing)
 811         ret |= AUDIO_STATUS_PLAY;
 812
 813     if (paused)
 814         ret |= AUDIO_STATUS_PAUSE;
 815
 816 #ifdef HAVE_RECORDING
 817     /* Do this here for constitency with mpeg.c version */
 818     /* FIXME: pcm_rec_status() is deprecated */
 819     ret |= pcm_rec_status();
 820 #endif
 821
 822     return ret;
 823 }
 824
 825 int audio_get_file_pos(void)
 826 {
 827     return 0;
 828 }
 829
 830 #ifdef HAVE_DISK_STORAGE
 831 void audio_set_buffer_margin(int setting)
 832 {
 833     static const unsigned short lookup[] = {5, 15, 30, 60, 120, 180, 300, 600};
 834     buffer_margin = lookup[setting];
 835     logf("buffer margin: %ld", (long)buffer_margin);
 836     set_filebuf_watermark();
 837 }
 838 #endif
 839
 840 #ifdef HAVE_CROSSFADE
 841 /* Take necessary steps to enable or disable the crossfade setting */
 842 void audio_set_crossfade(int enable)
 843 {
 844     size_t offset;
 845     bool was_playing;
 846     size_t size;
 847
 848     /* Tell it the next setting to use */
 849     pcmbuf_request_crossfade_enable(enable);
 850
 851     /* Return if size hasn't changed or this is too early to determine
 852        which in the second case there's no way we could be playing
 853        anything at all */
 854     if (pcmbuf_is_same_size()) return;
 855
 856     offset = 0;
 857     was_playing = playing;
 858
 859     /* Playback has to be stopped before changing the buffer size */
 860     if (was_playing)
 861     {
 862         /* Store the track resume position */
 863         offset = thistrack_id3->offset;
 864     }
 865
 866     /* Blast it - audio buffer will have to be setup again next time
 867        something plays */
 868     audio_get_buffer(true, &size);
 869
 870     /* Restart playback if audio was running previously */
 871     if (was_playing)
 872         audio_play(offset);
 873 }
 874 #endif
 875
 876 /* --- Routines called from multiple threads --- */
 877
 878 static void set_filebuf_watermark(void)
 879 {
 880     if (!filebuf)
 881         return;     /* Audio buffers not yet set up */
 882
 883 #ifdef HAVE_DISK_STORAGE
 884     int seconds;
 885     int spinup = ata_spinup_time();
 886     if (spinup)
 887         seconds = (spinup / HZ) + 1;
 888     else
 889         seconds = 5;
 890
 891     seconds += buffer_margin;
 892 #else
 893     /* flash storage */
 894     int seconds = 1;
 895 #endif
 896
 897     /* bitrate of last track in buffer dictates watermark */
 898     struct mp3entry* id3 = NULL;
 899     if (tracks[track_widx].taginfo_ready)
 900         id3 = bufgetid3(tracks[track_widx].id3_hid);
 901     else
 902         id3 = bufgetid3(tracks[track_widx-1].id3_hid);
 903     if (!id3) {
 904         logf("fwmark: No id3 for last track (r%d/w%d), aborting!", track_ridx, track_widx);
 905         return;
 906     }
 907     size_t bytes = id3->bitrate * (1000/8) * seconds;
 908     buf_set_watermark(bytes);
 909     logf("fwmark: %d", bytes);
 910 }
 911
 912 /* --- Buffering callbacks --- */
 913
 914 static void buffering_low_buffer_callback(void *data)
 915 {
 916     (void)data;
 917     logf("low buffer callback");
 918
 919     if (filling == STATE_FULL || filling == STATE_END_OF_PLAYLIST) {
 920         /* force a refill */
 921         LOGFQUEUE("buffering > audio Q_AUDIO_FILL_BUFFER");
 922         queue_post(&audio_queue, Q_AUDIO_FILL_BUFFER, 0);
 923     }
 924 }
 925
 926 static void buffering_handle_rebuffer_callback(void *data)
 927 {
 928     (void)data;
 929     LOGFQUEUE("audio >| audio Q_AUDIO_FLUSH");
 930     queue_post(&audio_queue, Q_AUDIO_FLUSH, 0);
 931 }
 932
 933 static void buffering_handle_finished_callback(void *data)
 934 {
 935     logf("handle %d finished buffering", *(int*)data);
 936     int hid = (*(int*)data);
 937
 938     if (hid == tracks[track_widx].id3_hid)
 939     {
 940         int offset = ci.new_track + wps_offset;
 941         int next_idx = (track_ridx + offset + 1) & MAX_TRACK_MASK;
 942         /* The metadata handle for the last loaded track has been buffered.
 943            We can ask the audio thread to load the rest of the track's data. */
 944         LOGFQUEUE("audio >| audio Q_AUDIO_FINISH_LOAD");
 945         queue_post(&audio_queue, Q_AUDIO_FINISH_LOAD, 0);
 946         if (tracks[next_idx].id3_hid == hid)
 947             send_event(PLAYBACK_EVENT_NEXTTRACKID3_AVAILABLE, NULL);
 948     }
 949     else
 950     {
 951         /* This is most likely an audio handle, so we strip the useless
 952            trailing tags that are left. */
 953         strip_tags(hid);
 954
 955         if (hid == tracks[track_widx-1].audio_hid
 956             && filling == STATE_END_OF_PLAYLIST)
 957         {
 958             /* This was the last track in the playlist.
 959                We now have all the data we need. */
 960             logf("last track finished buffering");
 961             filling = STATE_FINISHED;
 962         }
 963     }
 964 }
 965
 966
 967 /* --- Audio thread --- */
 968
 969 static bool audio_have_tracks(void)
 970 {
 971     return (audio_track_count() != 0);
 972 }
 973
 974 static int audio_free_track_count(void)
 975 {
 976     /* Used tracks + free tracks adds up to MAX_TRACK - 1 */
 977     return MAX_TRACK - 1 - audio_track_count();
 978 }
 979
 980 int audio_track_count(void)
 981 {
 982     /* Calculate difference from track_ridx to track_widx
 983      * taking into account a possible wrap-around. */
 984     return (MAX_TRACK + track_widx - track_ridx) & MAX_TRACK_MASK;
 985 }
 986
 987 long audio_filebufused(void)
 988 {
 989     return (long) buf_used();
 990 }
 991
 992 /* Update track info after successful a codec track change */
 993 static void audio_update_trackinfo(void)
 994 {
 995     /* Load the curent track's metadata into curtrack_id3 */
 996     if (CUR_TI->id3_hid >= 0)
 997         copy_mp3entry(thistrack_id3, bufgetid3(CUR_TI->id3_hid));
 998
 999     /* Reset current position */
1000     thistrack_id3->elapsed = 0;
1001     thistrack_id3->offset = 0;
1002
1003     /* Update the codec API */
1004     ci.filesize = CUR_TI->filesize;
1005     ci.id3 = thistrack_id3;
1006     ci.curpos = 0;
1007     ci.taginfo_ready = &CUR_TI->taginfo_ready;
1008 }
1009
1010 /* Clear tracks between write and read, non inclusive */
1011 static void audio_clear_track_entries(void)
1012 {
1013     int cur_idx = track_widx;
1014
1015     logf("Clearing tracks: r%d/w%d", track_ridx, track_widx);
1016
1017     /* Loop over all tracks from write-to-read */
1018     while (1)
1019     {
1020         cur_idx = (cur_idx + 1) & MAX_TRACK_MASK;
1021
1022         if (cur_idx == track_ridx)
1023             break;
1024
1025         clear_track_info(&tracks[cur_idx]);
1026     }
1027 }
1028
1029 /* Clear all tracks */
1030 static bool audio_release_tracks(void)
1031 {
1032     int i, cur_idx;
1033
1034     logf("releasing all tracks");
1035
1036     for(i = 0; i < MAX_TRACK; i++)
1037     {
1038         cur_idx = (track_ridx + i) & MAX_TRACK_MASK;
1039         if (!clear_track_info(&tracks[cur_idx]))
1040             return false;
1041     }
1042
1043     return true;
1044 }
1045
1046 static bool audio_loadcodec(bool start_play)
1047 {
1048     int prev_track;
1049     char codec_path[MAX_PATH]; /* Full path to codec */
1050     const struct mp3entry *id3, *prev_id3;
1051
1052     if (tracks[track_widx].id3_hid < 0) {
1053         return false;
1054     }
1055
1056     id3 = bufgetid3(tracks[track_widx].id3_hid);
1057     if (!id3)
1058         return false;
1059
1060     const char *codec_fn = get_codec_filename(id3->codectype);
1061     if (codec_fn == NULL)
1062         return false;
1063
1064     tracks[track_widx].codec_hid = -1;
1065
1066     if (start_play)
1067     {
1068         /* Load the codec directly from disk and save some memory. */
1069         track_ridx = track_widx;
1070         ci.filesize = CUR_TI->filesize;
1071         ci.id3 = thistrack_id3;
1072         ci.taginfo_ready = &CUR_TI->taginfo_ready;
1073         ci.curpos = 0;
1074         LOGFQUEUE("codec > codec Q_CODEC_LOAD_DISK");
1075         queue_post(&codec_queue, Q_CODEC_LOAD_DISK, (intptr_t)codec_fn);
1076         return true;
1077     }
1078     else
1079     {
1080         /* If we already have another track than this one buffered */
1081         if (track_widx != track_ridx)
1082         {
1083             prev_track = (track_widx - 1) & MAX_TRACK_MASK;
1084
1085             id3 = bufgetid3(tracks[track_widx].id3_hid);
1086             prev_id3 = bufgetid3(tracks[prev_track].id3_hid);
1087
1088             /* If the previous codec is the same as this one, there is no need
1089              * to put another copy of it on the file buffer */
1090             if (id3 && prev_id3 &&
1091                 get_codec_base_type(id3->codectype) ==
1092                 get_codec_base_type(prev_id3->codectype)
1093                 && audio_codec_loaded)
1094             {
1095                 logf("Reusing prev. codec");
1096                 return true;
1097             }
1098         }
1099     }
1100
1101     codec_get_full_path(codec_path, codec_fn);
1102
1103     tracks[track_widx].codec_hid = bufopen(codec_path, 0, TYPE_CODEC, NULL);
1104     if (tracks[track_widx].codec_hid < 0)
1105         return false;
1106
1107     logf("Loaded codec");
1108
1109     return true;
1110 }
1111
1112 /* Load metadata for the next track (with bufopen). The rest of the track
1113    loading will be handled by audio_finish_load_track once the metadata has been
1114    actually loaded by the buffering thread. */
1115 static bool audio_load_track(size_t offset, bool start_play)
1116 {
1117     const char *trackname;
1118     int fd = -1;
1119
1120     if (track_load_started) {
1121         /* There is already a track load in progress, so track_widx hasn't been
1122            incremented yet. Loading another track would overwrite the one that
1123            hasn't finished loading. */
1124         logf("audio_load_track(): a track load is already in progress");
1125         return false;
1126     }
1127
1128     start_play_g = start_play;  /* will be read by audio_finish_load_track */
1129
1130     /* Stop buffer filling if there is no free track entries.
1131        Don't fill up the last track entry (we wan't to store next track
1132        metadata there). */
1133     if (!audio_free_track_count())
1134     {
1135         logf("No free tracks");
1136         return false;
1137     }
1138
1139     last_peek_offset++;
1140     tracks[track_widx].taginfo_ready = false;
1141
1142     logf("Buffering track: r%d/w%d", track_ridx, track_widx);
1143     /* Get track name from current playlist read position. */
1144     while ((trackname = playlist_peek(last_peek_offset)) != NULL)
1145     {
1146         /* Handle broken playlists. */
1147         fd = open(trackname, O_RDONLY);
1148         if (fd < 0)
1149         {
1150             logf("Open failed");
1151             /* Skip invalid entry from playlist. */
1152             playlist_skip_entry(NULL, last_peek_offset);
1153         }
1154         else
1155             break;
1156     }
1157
1158     if (!trackname)
1159     {
1160         logf("End-of-playlist");
1161         memset(&unbuffered_id3, 0, sizeof(struct mp3entry));
1162         filling = STATE_END_OF_PLAYLIST;
1163
1164         if (thistrack_id3->length == 0 && thistrack_id3->filesize == 0)
1165         {
1166             /* Stop playback if no valid track was found. */
1167             audio_stop_playback();
1168         }
1169
1170         return false;
1171     }
1172
1173     tracks[track_widx].filesize = filesize(fd);
1174
1175     if (offset > tracks[track_widx].filesize)
1176         offset = 0;
1177
1178     /* Set default values */
1179     if (start_play)
1180     {
1181         buf_set_watermark(filebuflen/2);
1182         dsp_configure(ci.dsp, DSP_RESET, 0);
1183         playlist_update_resume_info(audio_current_track());
1184     }
1185
1186     /* Get track metadata if we don't already have it. */
1187     if (tracks[track_widx].id3_hid < 0)
1188     {
1189         tracks[track_widx].id3_hid = bufopen(trackname, 0, TYPE_ID3, NULL);
1190
1191         if (tracks[track_widx].id3_hid < 0)
1192         {
1193             /* Buffer is full. */
1194             get_metadata(&unbuffered_id3, fd, trackname);
1195             last_peek_offset--;
1196             close(fd);
1197             logf("buffer is full for now (get metadata)");
1198             filling = STATE_FULL;
1199             return false;
1200         }
1201
1202         if (track_widx == track_ridx)
1203         {
1204             /* TODO: Superfluos buffering call? */
1205             buf_request_buffer_handle(tracks[track_widx].id3_hid);
1206             struct mp3entry *id3 = bufgetid3(tracks[track_widx].id3_hid);
1207             if (id3)
1208             {
1209                 copy_mp3entry(thistrack_id3, id3);
1210                 thistrack_id3->offset = offset;
1211             }
1212             else
1213                 memset(thistrack_id3, 0, sizeof(struct mp3entry));
1214         }
1215
1216         if (start_play)
1217         {
1218             playlist_update_resume_info(audio_current_track());
1219         }
1220     }
1221
1222     close(fd);
1223     track_load_started = true; /* Remember that we've started loading a track */
1224     return true;
1225 }
1226
1227 /* Second part of the track loading: We now have the metadata available, so we
1228    can load the codec, the album art and finally the audio data.
1229    This is called on the audio thread after the buffering thread calls the
1230    buffering_handle_finished_callback callback. */
1231 static void audio_finish_load_track(void)
1232 {
1233     size_t file_offset = 0;
1234     size_t offset = 0;
1235     bool start_play = start_play_g;
1236
1237     track_load_started = false;
1238
1239     if (tracks[track_widx].id3_hid < 0) {
1240         logf("No metadata");
1241         return;
1242     }
1243
1244     struct mp3entry *track_id3;
1245
1246     if (track_widx == track_ridx)
1247         track_id3 = thistrack_id3;
1248     else
1249         track_id3 = bufgetid3(tracks[track_widx].id3_hid);
1250
1251     if (track_id3->length == 0 && track_id3->filesize == 0)
1252     {
1253         logf("audio_finish_load_track: invalid metadata");
1254
1255         /* Invalid metadata */
1256         bufclose(tracks[track_widx].id3_hid);
1257         tracks[track_widx].id3_hid = -1;
1258
1259         /* Skip invalid entry from playlist. */
1260         playlist_skip_entry(NULL, last_peek_offset--);
1261
1262         /* load next track */
1263         LOGFQUEUE("audio > audio Q_AUDIO_FILL_BUFFER %d", (int)start_play);
1264         queue_post(&audio_queue, Q_AUDIO_FILL_BUFFER, start_play);
1265
1266         return;
1267     }
1268     /* Try to load a cuesheet for the track */
1269     if (curr_cue)
1270     {
1271         char cuepath[MAX_PATH];
1272         if (look_for_cuesheet_file(track_id3->path, cuepath))
1273         {
1274             void *temp;
1275             tracks[track_widx].cuesheet_hid =
1276                         bufalloc(NULL, sizeof(struct cuesheet), TYPE_CUESHEET);
1277             if (tracks[track_widx].cuesheet_hid >= 0)
1278             {
1279                 bufgetdata(tracks[track_widx].cuesheet_hid,
1280                            sizeof(struct cuesheet), &temp);
1281                 struct cuesheet *cuesheet = (struct cuesheet*)temp;
1282                 if (!parse_cuesheet(cuepath, cuesheet))
1283                 {
1284                     bufclose(tracks[track_widx].cuesheet_hid);
1285                     track_id3->cuesheet = NULL;
1286                 }
1287             }
1288         }
1289     }
1290 #ifdef HAVE_ALBUMART
1291     {
1292         int i;
1293         char aa_path[MAX_PATH];
1294         FOREACH_ALBUMART(i)
1295         {
1296             /* albumart_slots may change during a yield of bufopen,
1297              * but that's no problem */
1298             if (tracks[track_widx].aa_hid[i] >= 0 || !albumart_slots[i].used)
1299                 continue;
1300             /* find_albumart will error out if the wps doesn't have AA */
1301             if (find_albumart(track_id3, aa_path, sizeof(aa_path),
1302                                &(albumart_slots[i].dim)))
1303             {
1304                 int aa_hid = bufopen(aa_path, 0, TYPE_BITMAP,
1305                                                 &(albumart_slots[i].dim));
1306
1307                 if(aa_hid == ERR_BUFFER_FULL)
1308                 {
1309                     filling = STATE_FULL;
1310                     logf("buffer is full for now (get album art)");
1311                     return;  /* No space for track's album art, not an error */
1312                 }
1313                 else if (aa_hid < 0)
1314                 {
1315                     /* another error, ignore AlbumArt */
1316                     logf("Album art loading failed");
1317                 }
1318                 tracks[track_widx].aa_hid[i] = aa_hid;
1319             }
1320         }
1321
1322     }
1323 #endif
1324
1325     /* Load the codec. */
1326     if (!audio_loadcodec(start_play))
1327     {
1328         if (tracks[track_widx].codec_hid == ERR_BUFFER_FULL)
1329         {
1330             /* No space for codec on buffer, not an error */
1331             filling = STATE_FULL;
1332             return;
1333         }
1334
1335         /* This is an error condition, either no codec was found, or reading
1336          * the codec file failed part way through, either way, skip the track */
1337         /* FIXME: We should not use splashf from audio thread! */
1338         splashf(HZ*2, "No codec for: %s", track_id3->path);
1339         /* Skip invalid entry from playlist. */
1340         playlist_skip_entry(NULL, last_peek_offset);
1341         return;
1342     }
1343
1344     track_id3->elapsed = 0;
1345     offset = track_id3->offset;
1346
1347     enum data_type type = TYPE_PACKET_AUDIO;
1348
1349     switch (track_id3->codectype) {
1350     case AFMT_MPA_L1:
1351     case AFMT_MPA_L2:
1352     case AFMT_MPA_L3:
1353         if (offset > 0) {
1354             file_offset = offset;
1355             track_id3->offset = offset;
1356         }
1357         break;
1358
1359     case AFMT_WAVPACK:
1360         if (offset > 0) {
1361             file_offset = offset;
1362             track_id3->offset = offset;
1363             track_id3->elapsed = track_id3->length / 2;
1364         }
1365         break;
1366
1367     case AFMT_OGG_VORBIS:
1368     case AFMT_SPEEX:
1369     case AFMT_FLAC:
1370     case AFMT_PCM_WAV:
1371     case AFMT_A52:
1372     case AFMT_MP4_AAC:
1373     case AFMT_MPC:
1374     case AFMT_APE:
1375     case AFMT_WMA:
1376         if (offset > 0)
1377             track_id3->offset = offset;
1378         break;
1379
1380     case AFMT_NSF:
1381     case AFMT_SPC:
1382     case AFMT_SID:
1383         logf("Loading atomic %d",track_id3->codectype);
1384         type = TYPE_ATOMIC_AUDIO;
1385         break;
1386     }
1387
1388     logf("load track: %s", track_id3->path);
1389
1390     if (file_offset > AUDIO_REBUFFER_GUESS_SIZE)
1391         file_offset -= AUDIO_REBUFFER_GUESS_SIZE;
1392     else if (track_id3->first_frame_offset)
1393         file_offset = track_id3->first_frame_offset;
1394     else
1395         file_offset = 0;
1396
1397     tracks[track_widx].audio_hid = bufopen(track_id3->path, file_offset, type,
1398                                             NULL);
1399
1400     /* No space left, not an error */
1401     if (tracks[track_widx].audio_hid == ERR_BUFFER_FULL)
1402     {
1403         filling = STATE_FULL;
1404         logf("buffer is full for now (load audio)");
1405         return;
1406     }
1407     else if (tracks[track_widx].audio_hid < 0)
1408     {
1409         /* another error, do not continue either */
1410         logf("Could not add audio data handle");
1411         return;
1412     }
1413
1414     /* All required data is now available for the codec. */
1415     tracks[track_widx].taginfo_ready = true;
1416
1417     if (start_play)
1418     {
1419         ci.curpos=file_offset;
1420         buf_request_buffer_handle(tracks[track_widx].audio_hid);
1421     }
1422
1423     track_widx = (track_widx + 1) & MAX_TRACK_MASK;
1424
1425     send_event(PLAYBACK_EVENT_TRACK_BUFFER, track_id3);
1426
1427     /* load next track */
1428     LOGFQUEUE("audio > audio Q_AUDIO_FILL_BUFFER");
1429     queue_post(&audio_queue, Q_AUDIO_FILL_BUFFER, 0);
1430
1431     return;
1432 }
1433
1434 static void audio_fill_file_buffer(bool start_play, size_t offset)
1435 {
1436     trigger_cpu_boost();
1437
1438     /* No need to rebuffer if there are track skips pending,
1439      * however don't cancel buffering on skipping while filling. */
1440     if (ci.new_track != 0 && filling != STATE_FILLING)
1441         return;
1442     filling = STATE_FILLING;
1443
1444     /* Must reset the buffer before use if trashed or voice only - voice
1445        file size shouldn't have changed so we can go straight from
1446        AUDIOBUF_STATE_VOICED_ONLY to AUDIOBUF_STATE_INITIALIZED */
1447     if (buffer_state != AUDIOBUF_STATE_INITIALIZED)
1448         audio_reset_buffer();
1449
1450     logf("Starting buffer fill");
1451
1452     if (!start_play)
1453         audio_clear_track_entries();
1454
1455     /* Save the current resume position once. */
1456     playlist_update_resume_info(audio_current_track());
1457
1458     audio_load_track(offset, start_play);
1459 }
1460
1461 static void audio_rebuffer(void)
1462 {
1463     logf("Forcing rebuffer");
1464
1465     clear_track_info(CUR_TI);
1466
1467     /* Reset track pointers */
1468     track_widx = track_ridx;
1469     audio_clear_track_entries();
1470
1471     /* Reset a possibly interrupted track load */
1472     track_load_started = false;
1473
1474     /* Fill the buffer */
1475     last_peek_offset = -1;
1476     ci.curpos = 0;
1477
1478     if (!CUR_TI->taginfo_ready)
1479         memset(thistrack_id3, 0, sizeof(struct mp3entry));
1480
1481     audio_fill_file_buffer(false, 0);
1482 }
1483
1484 /* Called on request from the codec to get a new track. This is the codec part
1485    of the track transition. */
1486 static int audio_check_new_track(void)
1487 {
1488     int track_count = audio_track_count();
1489     int old_track_ridx = track_ridx;
1490     int i, idx;
1491     bool forward;
1492     struct mp3entry *temp = thistrack_id3;
1493
1494     /* Now it's good time to send track finish events. */
1495     send_event(PLAYBACK_EVENT_TRACK_FINISH, thistrack_id3);
1496     /* swap the mp3entry pointers */
1497     thistrack_id3 = othertrack_id3;
1498     othertrack_id3 = temp;
1499     ci.id3 = thistrack_id3;
1500     memset(thistrack_id3, 0, sizeof(struct mp3entry));
1501
1502     if (dir_skip)
1503     {
1504         dir_skip = false;
1505         /* regardless of the return value we need to rebuffer.
1506            if it fails the old playlist will resume, else the
1507            next dir will start playing */
1508         playlist_next_dir(ci.new_track);
1509         ci.new_track = 0;
1510         audio_rebuffer();
1511         goto skip_done;
1512     }
1513
1514     if (new_playlist)
1515         ci.new_track = 0;
1516
1517     /* If the playlist isn't that big */
1518     if (automatic_skip)
1519     {
1520         while (!playlist_check(ci.new_track))
1521         {
1522             if (ci.new_track >= 0)
1523             {
1524                 LOGFQUEUE("audio >|= codec Q_CODEC_REQUEST_FAILED");
1525                 return Q_CODEC_REQUEST_FAILED;
1526             }
1527             ci.new_track++;
1528         }
1529     }
1530
1531     /* Update the playlist */
1532     last_peek_offset -= ci.new_track;
1533
1534     if (playlist_next(ci.new_track) < 0)
1535     {
1536         LOGFQUEUE("audio >|= codec Q_CODEC_REQUEST_FAILED");
1537         return Q_CODEC_REQUEST_FAILED;
1538     }
1539
1540     if (new_playlist)
1541     {
1542         ci.new_track = 1;
1543         new_playlist = false;
1544     }
1545
1546     /* Save a pointer to the old track to allow later clearing */
1547     prev_ti = CUR_TI;
1548
1549     for (i = 0; i < ci.new_track; i++)
1550     {
1551         idx = (track_ridx + i) & MAX_TRACK_MASK;
1552         struct mp3entry *id3 = bufgetid3(tracks[idx].id3_hid);
1553         ssize_t offset = buf_handle_offset(tracks[idx].audio_hid);
1554         if (!id3 || offset < 0 || (unsigned)offset > id3->first_frame_offset)
1555         {
1556             /* We don't have all the audio data for that track, so clear it,
1557                but keep the metadata. */
1558             if (tracks[idx].audio_hid >= 0 && bufclose(tracks[idx].audio_hid))
1559             {
1560                 tracks[idx].audio_hid = -1;
1561                 tracks[idx].filesize = 0;
1562             }
1563         }
1564     }
1565
1566     /* Move to the new track */
1567     track_ridx = (track_ridx + ci.new_track) & MAX_TRACK_MASK;
1568     buf_set_base_handle(CUR_TI->audio_hid);
1569
1570
1571     if (automatic_skip)
1572     {
1573         wps_offset = -ci.new_track;
1574     }
1575
1576     /* If it is not safe to even skip this many track entries */
1577     if (ci.new_track >= track_count || ci.new_track <= track_count - MAX_TRACK)
1578     {
1579         ci.new_track = 0;
1580         audio_rebuffer();
1581         goto skip_done;
1582     }
1583
1584     forward = ci.new_track > 0;
1585     ci.new_track = 0;
1586
1587     /* If the target track is clearly not in memory */
1588     if (CUR_TI->filesize == 0 || !CUR_TI->taginfo_ready)
1589     {
1590         audio_rebuffer();
1591         goto skip_done;
1592     }
1593
1594     /* When skipping backwards, it is possible that we've found a track that's
1595      * buffered, but which is around the track-wrap and therefore not the track
1596      * we are looking for */
1597     if (!forward)
1598     {
1599         int cur_idx = track_ridx;
1600         bool taginfo_ready = true;
1601         /* We've wrapped the buffer backwards if new > old */
1602         bool wrap = track_ridx > old_track_ridx;
1603
1604         while (1)
1605         {
1606             cur_idx = (cur_idx + 1) & MAX_TRACK_MASK;
1607
1608             /* if we've advanced past the wrap when cur_idx is zeroed */
1609             if (!cur_idx)
1610                 wrap = false;
1611
1612             /* if we aren't still on the wrap and we've caught the old track */
1613             if (!(wrap || cur_idx < old_track_ridx))
1614                 break;
1615
1616             /* If we hit a track in between without valid tag info, bail */
1617             if (!tracks[cur_idx].taginfo_ready)
1618             {
1619                 taginfo_ready = false;
1620                 break;
1621             }
1622         }
1623         if (!taginfo_ready)
1624         {
1625             audio_rebuffer();
1626         }
1627     }
1628
1629 skip_done:
1630     audio_update_trackinfo();
1631     LOGFQUEUE("audio >|= codec Q_CODEC_REQUEST_COMPLETE");
1632     return Q_CODEC_REQUEST_COMPLETE;
1633 }
1634
1635 unsigned long audio_prev_elapsed(void)
1636 {
1637     return prev_track_elapsed;
1638 }
1639
1640 void audio_set_prev_elapsed(unsigned long setting)
1641 {
1642     prev_track_elapsed = setting;
1643 }
1644
1645 static void audio_stop_codec_flush(void)
1646 {
1647     ci.stop_codec = true;
1648     pcmbuf_pause(true);
1649
1650     while (audio_codec_loaded)
1651         yield();
1652
1653     /* If the audio codec is not loaded any more, and the audio is still
1654      * playing, it is now and _only_ now safe to call this function from the
1655      * audio thread */
1656     if (pcm_is_playing())
1657     {
1658         pcmbuf_play_stop();
1659         pcm_play_lock();
1660         queue_clear(&pcmbuf_queue);
1661         pcm_play_unlock();
1662     }
1663     pcmbuf_pause(paused);
1664 }
1665
1666 static void audio_stop_playback(void)
1667 {
1668     if (playing)
1669     {
1670         /* If we were playing, save resume information */
1671         struct mp3entry *id3 = NULL;
1672
1673         if (!ci.stop_codec)
1674         {
1675             /* Set this early, the outside code yields and may allow the codec
1676                to try to wait for a reply on a buffer wait */
1677             ci.stop_codec = true;
1678             id3 = audio_current_track();
1679         }
1680
1681         /* Save the current playing spot, or NULL if the playlist has ended */
1682         playlist_update_resume_info(id3);
1683
1684         /* TODO: Create auto bookmark too? */
1685
1686         prev_track_elapsed = othertrack_id3->elapsed;
1687
1688         remove_event(BUFFER_EVENT_BUFFER_LOW, buffering_low_buffer_callback);
1689     }
1690
1691     audio_stop_codec_flush();
1692     paused = false;
1693     playing = false;
1694     track_load_started = false;
1695
1696     filling = STATE_IDLE;
1697
1698     /* Mark all entries null. */
1699     audio_clear_track_entries();
1700
1701     /* Close all tracks */
1702     audio_release_tracks();
1703 }
1704
1705 static void audio_play_start(size_t offset)
1706 {
1707     int i;
1708
1709 #if INPUT_SRC_CAPS != 0
1710     audio_set_input_source(AUDIO_SRC_PLAYBACK, SRCF_PLAYBACK);
1711     audio_set_output_source(AUDIO_SRC_PLAYBACK);
1712 #endif
1713
1714     /* Wait for any previously playing audio to flush - TODO: Not necessary? */
1715     paused = false;
1716     audio_stop_codec_flush();
1717
1718     playing = true;
1719     track_load_started = false;
1720
1721     ci.new_track = 0;
1722     ci.seek_time = 0;
1723     wps_offset = 0;
1724
1725     sound_set_volume(global_settings.volume);
1726     track_widx = track_ridx = 0;
1727     buf_set_base_handle(-1);
1728
1729     /* Clear all track entries. */
1730     for (i = 0; i < MAX_TRACK; i++) {
1731         clear_track_info(&tracks[i]);
1732     }
1733
1734     last_peek_offset = -1;
1735
1736     /* Officially playing */
1737     queue_reply(&audio_queue, 1);
1738
1739     audio_fill_file_buffer(true, offset);
1740
1741     add_event(BUFFER_EVENT_BUFFER_LOW, false, buffering_low_buffer_callback);
1742
1743     LOGFQUEUE("audio > audio Q_AUDIO_TRACK_CHANGED");
1744     queue_post(&audio_queue, Q_AUDIO_TRACK_CHANGED, 0);
1745 }
1746
1747
1748 /* Invalidates all but currently playing track. */
1749 static void audio_invalidate_tracks(void)
1750 {
1751     if (audio_have_tracks())
1752     {
1753         last_peek_offset = 0;
1754         track_widx = track_ridx;
1755
1756         /* Mark all other entries null (also buffered wrong metadata). */
1757         audio_clear_track_entries();
1758
1759         track_widx = (track_widx + 1) & MAX_TRACK_MASK;
1760
1761         audio_fill_file_buffer(false, 0);
1762         send_event(PLAYBACK_EVENT_TRACK_CHANGE, thistrack_id3);
1763     }
1764 }
1765
1766 static void audio_new_playlist(void)
1767 {
1768     /* Prepare to start a new fill from the beginning of the playlist */
1769     last_peek_offset = -1;
1770     if (audio_have_tracks())
1771     {
1772         if (paused)
1773             skipped_during_pause = true;
1774         track_widx = track_ridx;
1775         audio_clear_track_entries();
1776
1777         track_widx = (track_widx + 1) & MAX_TRACK_MASK;
1778
1779         /* Mark the current track as invalid to prevent skipping back to it */
1780         CUR_TI->taginfo_ready = false;
1781     }
1782
1783     /* Signal the codec to initiate a track change forward */
1784     new_playlist = true;
1785     ci.new_track = 1;
1786
1787     /* Officially playing */
1788     queue_reply(&audio_queue, 1);
1789
1790     audio_fill_file_buffer(false, 0);
1791 }
1792
1793 /* Called on manual track skip */
1794 static void audio_initiate_track_change(long direction)
1795 {
1796     logf("audio_initiate_track_change(%ld)", direction);
1797
1798     ci.new_track += direction;
1799     wps_offset -= direction;
1800     if (paused)
1801         skipped_during_pause = true;
1802 }
1803
1804 /* Called on manual dir skip */
1805 static void audio_initiate_dir_change(long direction)
1806 {
1807     dir_skip = true;
1808     ci.new_track = direction;
1809     if (paused)
1810         skipped_during_pause = true;
1811 }
1812
1813 /* Called when PCM track change is complete */
1814 static void audio_finalise_track_change(void)
1815 {
1816     logf("audio_finalise_track_change");
1817
1818     if (automatic_skip)
1819     {
1820         wps_offset = 0;
1821         automatic_skip = false;
1822
1823         /* Invalidate prevtrack_id3 */
1824         memset(othertrack_id3, 0, sizeof(struct mp3entry));
1825
1826         if (prev_ti && prev_ti->audio_hid < 0)
1827         {
1828             /* No audio left so we clear all the track info. */
1829             clear_track_info(prev_ti);
1830         }
1831     }
1832     send_event(PLAYBACK_EVENT_TRACK_CHANGE, thistrack_id3);
1833     playlist_update_resume_info(audio_current_track());
1834 }
1835
1836 /*
1837  * Layout audio buffer as follows - iram buffer depends on target:
1838  * [|SWAP:iram][|TALK]|FILE|GUARD|PCM|[SWAP:dram[|iram]|]
1839  */
1840 static void audio_reset_buffer(void)
1841 {
1842     /* see audio_get_recording_buffer if this is modified */
1843     logf("audio_reset_buffer");
1844
1845     /* If the setup of anything allocated before the file buffer is
1846        changed, do check the adjustments after the buffer_alloc call
1847        as it will likely be affected and need sliding over */
1848
1849     /* Initially set up file buffer as all space available */
1850     malloc_buf = audiobuf + talk_get_bufsize();
1851     /* Align the malloc buf to line size. Especially important to cf
1852        targets that do line reads/writes. */
1853     malloc_buf = (unsigned char *)(((uintptr_t)malloc_buf + 15) & ~15);
1854     filebuf    = malloc_buf; /* filebuf line align implied */
1855     filebuflen = audiobufend - filebuf;
1856
1857     filebuflen &= ~15;
1858
1859     /* Subtract whatever the pcm buffer says it used plus the guard buffer */
1860     const size_t pcmbuf_size = pcmbuf_init(filebuf + filebuflen) +GUARD_BUFSIZE;
1861
1862 #ifdef DEBUG
1863     if(pcmbuf_size > filebuflen)
1864         panicf("Not enough memory for pcmbuf_init() : %d > %d",
1865                 (int)pcmbuf_size, (int)filebuflen);
1866 #endif
1867
1868     filebuflen -= pcmbuf_size;
1869
1870     /* Make sure filebuflen is a longword multiple after adjustment - filebuf
1871        will already be line aligned */
1872     filebuflen &= ~3;
1873
1874     buffering_reset(filebuf, filebuflen);
1875
1876     /* Clear any references to the file buffer */
1877     buffer_state = AUDIOBUF_STATE_INITIALIZED;
1878
1879 #if defined(ROCKBOX_HAS_LOGF) && defined(LOGF_ENABLE)
1880     /* Make sure everything adds up - yes, some info is a bit redundant but
1881        aids viewing and the sumation of certain variables should add up to
1882        the location of others. */
1883     {
1884         size_t pcmbufsize;
1885         const unsigned char *pcmbuf = pcmbuf_get_meminfo(&pcmbufsize);
1886         logf("mabuf:  %08X", (unsigned)malloc_buf);
1887         logf("fbuf:   %08X", (unsigned)filebuf);
1888         logf("fbufe:  %08X", (unsigned)(filebuf + filebuflen));
1889         logf("gbuf:   %08X", (unsigned)(filebuf + filebuflen));
1890         logf("gbufe:  %08X", (unsigned)(filebuf + filebuflen + GUARD_BUFSIZE));
1891         logf("pcmb:   %08X", (unsigned)pcmbuf);
1892         logf("pcmbe:  %08X", (unsigned)(pcmbuf + pcmbufsize));
1893     }
1894 #endif
1895 }
1896
1897 static void audio_thread(void)
1898 {
1899     struct queue_event ev;
1900
1901     pcm_postinit();
1902
1903     audio_thread_ready = true;
1904
1905     while (1)
1906     {
1907         if (filling != STATE_FILLING && filling != STATE_IDLE) {
1908             /* End of buffering, let's calculate the watermark and unboost */
1909             set_filebuf_watermark();
1910             cancel_cpu_boost();
1911         }
1912
1913         if (!pcmbuf_queue_scan(&ev))
1914             queue_wait_w_tmo(&audio_queue, &ev, HZ/2);
1915
1916         switch (ev.id) {
1917
1918             case Q_AUDIO_FILL_BUFFER:
1919                 LOGFQUEUE("audio < Q_AUDIO_FILL_BUFFER %d", (int)ev.data);
1920                 audio_fill_file_buffer((bool)ev.data, 0);
1921                 break;
1922
1923             case Q_AUDIO_FINISH_LOAD:
1924                 LOGFQUEUE("audio < Q_AUDIO_FINISH_LOAD");
1925                 audio_finish_load_track();
1926                 buf_set_base_handle(CUR_TI->audio_hid);
1927                 break;
1928
1929             case Q_AUDIO_PLAY:
1930                 LOGFQUEUE("audio < Q_AUDIO_PLAY");
1931                 if (playing && ev.data <= 0)
1932                     audio_new_playlist();
1933                 else
1934                 {
1935                     audio_stop_playback();
1936                     audio_play_start((size_t)ev.data);
1937                 }
1938                 break;
1939
1940             case Q_AUDIO_STOP:
1941                 LOGFQUEUE("audio < Q_AUDIO_STOP");
1942                 if (playing)
1943                     audio_stop_playback();
1944                 if (ev.data != 0)
1945                     queue_clear(&audio_queue);
1946                 break;
1947
1948             case Q_AUDIO_PAUSE:
1949                 LOGFQUEUE("audio < Q_AUDIO_PAUSE");
1950                 if (!(bool) ev.data && skipped_during_pause
1951 #ifdef HAVE_CROSSFADE
1952                     && !pcmbuf_is_crossfade_active()
1953 #endif
1954                     )
1955                     pcmbuf_play_stop(); /* Flush old track on resume after skip */
1956                 skipped_during_pause = false;
1957                 if (!playing)
1958                     break;
1959                 pcmbuf_pause((bool)ev.data);
1960                 paused = (bool)ev.data;
1961                 break;
1962
1963             case Q_AUDIO_SKIP:
1964                 LOGFQUEUE("audio < Q_AUDIO_SKIP");
1965                 audio_initiate_track_change((long)ev.data);
1966                 break;
1967
1968             case Q_AUDIO_PRE_FF_REWIND:
1969                 LOGFQUEUE("audio < Q_AUDIO_PRE_FF_REWIND");
1970                 if (!playing)
1971                     break;
1972                 pcmbuf_pause(true);
1973                 break;
1974
1975             case Q_AUDIO_FF_REWIND:
1976                 LOGFQUEUE("audio < Q_AUDIO_FF_REWIND");
1977                 if (!playing)
1978                     break;
1979                 if (automatic_skip)
1980                 {
1981                     /* An automatic track skip is in progress. Finalize it,
1982                        then go back to the previous track */
1983                     audio_finalise_track_change();
1984                     ci.new_track = -1;
1985                 }
1986                 ci.seek_time = (long)ev.data+1;
1987                 break;
1988
1989             case Q_AUDIO_CHECK_NEW_TRACK:
1990                 LOGFQUEUE("audio < Q_AUDIO_CHECK_NEW_TRACK");
1991                 queue_reply(&audio_queue, audio_check_new_track());
1992                 break;
1993
1994             case Q_AUDIO_DIR_SKIP:
1995                 LOGFQUEUE("audio < Q_AUDIO_DIR_SKIP");
1996                 audio_initiate_dir_change(ev.data);
1997                 break;
1998
1999             case Q_AUDIO_FLUSH:
2000                 LOGFQUEUE("audio < Q_AUDIO_FLUSH");
2001                 audio_invalidate_tracks();
2002                 break;
2003
2004             case Q_AUDIO_TRACK_CHANGED:
2005                 /* PCM track change done */
2006                 LOGFQUEUE("audio < Q_AUDIO_TRACK_CHANGED");
2007                 audio_finalise_track_change();
2008                 break;
2009 #ifndef SIMULATOR
2010             case SYS_USB_CONNECTED:
2011                 LOGFQUEUE("audio < SYS_USB_CONNECTED");
2012                 if (playing)
2013                     audio_stop_playback();
2014 #ifdef PLAYBACK_VOICE
2015                 voice_stop();
2016 #endif
2017                 usb_acknowledge(SYS_USB_CONNECTED_ACK);
2018                 usb_wait_for_disconnect(&audio_queue);
2019
2020                 /* Mark all entries null. */
2021                 audio_clear_track_entries();
2022
2023                 /* release tracks to make sure all handles are closed */
2024                 audio_release_tracks();
2025                 break;
2026 #endif
2027
2028             case SYS_TIMEOUT:
2029                 LOGFQUEUE_SYS_TIMEOUT("audio < SYS_TIMEOUT");
2030                 break;
2031
2032             default:
2033                 /* LOGFQUEUE("audio < default : %08lX", ev.id); */
2034                 break;
2035         } /* end switch */
2036     } /* end while */
2037 }
2038
2039 /* Initialize the audio system - called from init() in main.c.
2040  * Last function because of all the references to internal symbols
2041  */
2042 void audio_init(void)
2043 {
2044     unsigned int audio_thread_id;
2045
2046     /* Can never do this twice */
2047     if (audio_is_initialized)
2048     {
2049         logf("audio: already initialized");
2050         return;
2051     }
2052
2053     logf("audio: initializing");
2054
2055     /* Initialize queues before giving control elsewhere in case it likes
2056        to send messages. Thread creation will be delayed however so nothing
2057        starts running until ready if something yields such as talk_init. */
2058     queue_init(&audio_queue, true);
2059     queue_init(&codec_queue, false);
2060     queue_init(&pcmbuf_queue, false);
2061
2062     pcm_init();
2063
2064     codec_init_codec_api();
2065
2066     thistrack_id3 = &mp3entry_buf[0];
2067     othertrack_id3 = &mp3entry_buf[1];
2068
2069     /* cuesheet support */
2070     if (global_settings.cuesheet)
2071         curr_cue = (struct cuesheet*)buffer_alloc(sizeof(struct cuesheet));
2072
2073     /* initialize the buffer */
2074     filebuf = audiobuf;
2075
2076     /* audio_reset_buffer must to know the size of voice buffer so init
2077        talk first */
2078     talk_init();
2079
2080     make_codec_thread();
2081
2082     audio_thread_id = create_thread(audio_thread, audio_stack,
2083                   sizeof(audio_stack), CREATE_THREAD_FROZEN,
2084                   audio_thread_name IF_PRIO(, PRIORITY_USER_INTERFACE)
2085                   IF_COP(, CPU));
2086
2087     queue_enable_queue_send(&audio_queue, &audio_queue_sender_list,
2088                             audio_thread_id);
2089
2090 #ifdef PLAYBACK_VOICE
2091     voice_thread_init();
2092 #endif
2093
2094 #ifdef HAVE_CROSSFADE
2095     /* Set crossfade setting for next buffer init which should be about... */
2096     pcmbuf_request_crossfade_enable(global_settings.crossfade);
2097 #endif
2098
2099     /* initialize the buffering system */
2100
2101     buffering_init();
2102     /* ...now! Set up the buffers */
2103     audio_reset_buffer();
2104
2105     int i;
2106     for(i = 0; i < MAX_TRACK; i++)
2107     {
2108         tracks[i].audio_hid = -1;
2109         tracks[i].id3_hid = -1;
2110         tracks[i].codec_hid = -1;
2111         tracks[i].cuesheet_hid = -1;
2112     }
2113 #ifdef HAVE_ALBUMART
2114     FOREACH_ALBUMART(i)
2115     {
2116         int j;
2117         for (j = 0; j < MAX_TRACK; j++)
2118         {
2119             tracks[j].aa_hid[i] = -1;
2120         }
2121     }
2122 #endif
2123
2124     add_event(BUFFER_EVENT_REBUFFER, false, buffering_handle_rebuffer_callback);
2125     add_event(BUFFER_EVENT_FINISHED, false, buffering_handle_finished_callback);
2126
2127     /* Probably safe to say */
2128     audio_is_initialized = true;
2129
2130     sound_settings_apply();
2131 #ifdef HAVE_DISK_STORAGE
2132     audio_set_buffer_margin(global_settings.buffer_margin);
2133 #endif
2134
2135     /* it's safe to let the threads run now */
2136 #ifdef PLAYBACK_VOICE
2137     voice_thread_resume();
2138 #endif
2139     thread_thaw(codec_thread_id);
2140     thread_thaw(audio_thread_id);
2141
2142 } /* audio_init */
2143
2144 bool audio_is_thread_ready(void)
2145 {
2146     return audio_thread_ready;
2147 }
2148
2149 size_t audio_get_filebuflen(void)
2150 {
2151     return filebuflen;
2152 }
2153
2154 int get_audio_hid()
2155 {
2156     return CUR_TI->audio_hid;
2157 }
2158
2159 int *get_codec_hid()
2160 {
2161     return &tracks[track_ridx].codec_hid;
2162 }