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
1569
1570     if (automatic_skip)
1571     {
1572         wps_offset = -ci.new_track;
1573     }
1574
1575     /* If it is not safe to even skip this many track entries */
1576     if (ci.new_track >= track_count || ci.new_track <= track_count - MAX_TRACK)
1577     {
1578         ci.new_track = 0;
1579         audio_rebuffer();
1580         goto skip_done;
1581     }
1582
1583     forward = ci.new_track > 0;
1584     ci.new_track = 0;
1585
1586     /* If the target track is clearly not in memory */
1587     if (CUR_TI->filesize == 0 || !CUR_TI->taginfo_ready)
1588     {
1589         audio_rebuffer();
1590         goto skip_done;
1591     }
1592
1593     /* When skipping backwards, it is possible that we've found a track that's
1594      * buffered, but which is around the track-wrap and therefore not the track
1595      * we are looking for */
1596     if (!forward)
1597     {
1598         int cur_idx = track_ridx;
1599         bool taginfo_ready = true;
1600         /* We've wrapped the buffer backwards if new > old */
1601         bool wrap = track_ridx > old_track_ridx;
1602
1603         while (1)
1604         {
1605             cur_idx = (cur_idx + 1) & MAX_TRACK_MASK;
1606
1607             /* if we've advanced past the wrap when cur_idx is zeroed */
1608             if (!cur_idx)
1609                 wrap = false;
1610
1611             /* if we aren't still on the wrap and we've caught the old track */
1612             if (!(wrap || cur_idx < old_track_ridx))
1613                 break;
1614
1615             /* If we hit a track in between without valid tag info, bail */
1616             if (!tracks[cur_idx].taginfo_ready)
1617             {
1618                 taginfo_ready = false;
1619                 break;
1620             }
1621         }
1622         if (!taginfo_ready)
1623         {
1624             audio_rebuffer();
1625         }
1626     }
1627
1628 skip_done:
1629     audio_update_trackinfo();
1630     LOGFQUEUE("audio >|= codec Q_CODEC_REQUEST_COMPLETE");
1631     return Q_CODEC_REQUEST_COMPLETE;
1632 }
1633
1634 unsigned long audio_prev_elapsed(void)
1635 {
1636     return prev_track_elapsed;
1637 }
1638
1639 void audio_set_prev_elapsed(unsigned long setting)
1640 {
1641     prev_track_elapsed = setting;
1642 }
1643
1644 static void audio_stop_codec_flush(void)
1645 {
1646     ci.stop_codec = true;
1647     pcmbuf_pause(true);
1648
1649     while (audio_codec_loaded)
1650         yield();
1651
1652     /* If the audio codec is not loaded any more, and the audio is still
1653      * playing, it is now and _only_ now safe to call this function from the
1654      * audio thread */
1655     if (pcm_is_playing())
1656     {
1657         pcmbuf_play_stop();
1658         pcm_play_lock();
1659         queue_clear(&pcmbuf_queue);
1660         pcm_play_unlock();
1661     }
1662     pcmbuf_pause(paused);
1663 }
1664
1665 static void audio_stop_playback(void)
1666 {
1667     if (playing)
1668     {
1669         /* If we were playing, save resume information */
1670         struct mp3entry *id3 = NULL;
1671
1672         if (!ci.stop_codec)
1673         {
1674             /* Set this early, the outside code yields and may allow the codec
1675                to try to wait for a reply on a buffer wait */
1676             ci.stop_codec = true;
1677             id3 = audio_current_track();
1678         }
1679
1680         /* Save the current playing spot, or NULL if the playlist has ended */
1681         playlist_update_resume_info(id3);
1682
1683         /* TODO: Create auto bookmark too? */
1684
1685         prev_track_elapsed = othertrack_id3->elapsed;
1686
1687         remove_event(BUFFER_EVENT_BUFFER_LOW, buffering_low_buffer_callback);
1688     }
1689
1690     audio_stop_codec_flush();
1691     paused = false;
1692     playing = false;
1693     track_load_started = false;
1694
1695     filling = STATE_IDLE;
1696
1697     /* Mark all entries null. */
1698     audio_clear_track_entries();
1699
1700     /* Close all tracks */
1701     audio_release_tracks();
1702 }
1703
1704 static void audio_play_start(size_t offset)
1705 {
1706     int i;
1707
1708 #if INPUT_SRC_CAPS != 0
1709     audio_set_input_source(AUDIO_SRC_PLAYBACK, SRCF_PLAYBACK);
1710     audio_set_output_source(AUDIO_SRC_PLAYBACK);
1711 #endif
1712
1713     /* Wait for any previously playing audio to flush - TODO: Not necessary? */
1714     paused = false;
1715     audio_stop_codec_flush();
1716
1717     playing = true;
1718     track_load_started = false;
1719
1720     ci.new_track = 0;
1721     ci.seek_time = 0;
1722     wps_offset = 0;
1723
1724     sound_set_volume(global_settings.volume);
1725     track_widx = track_ridx = 0;
1726
1727     /* Clear all track entries. */
1728     for (i = 0; i < MAX_TRACK; i++) {
1729         clear_track_info(&tracks[i]);
1730     }
1731
1732     last_peek_offset = -1;
1733
1734     /* Officially playing */
1735     queue_reply(&audio_queue, 1);
1736
1737     audio_fill_file_buffer(true, offset);
1738
1739     add_event(BUFFER_EVENT_BUFFER_LOW, false, buffering_low_buffer_callback);
1740
1741     LOGFQUEUE("audio > audio Q_AUDIO_TRACK_CHANGED");
1742     queue_post(&audio_queue, Q_AUDIO_TRACK_CHANGED, 0);
1743 }
1744
1745
1746 /* Invalidates all but currently playing track. */
1747 static void audio_invalidate_tracks(void)
1748 {
1749     if (audio_have_tracks())
1750     {
1751         last_peek_offset = 0;
1752         track_widx = track_ridx;
1753
1754         /* Mark all other entries null (also buffered wrong metadata). */
1755         audio_clear_track_entries();
1756
1757         track_widx = (track_widx + 1) & MAX_TRACK_MASK;
1758
1759         audio_fill_file_buffer(false, 0);
1760     }
1761 }
1762
1763 static void audio_new_playlist(void)
1764 {
1765     /* Prepare to start a new fill from the beginning of the playlist */
1766     last_peek_offset = -1;
1767     if (audio_have_tracks())
1768     {
1769         if (paused)
1770             skipped_during_pause = true;
1771         track_widx = track_ridx;
1772         audio_clear_track_entries();
1773
1774         track_widx = (track_widx + 1) & MAX_TRACK_MASK;
1775
1776         /* Mark the current track as invalid to prevent skipping back to it */
1777         CUR_TI->taginfo_ready = false;
1778     }
1779
1780     /* Signal the codec to initiate a track change forward */
1781     new_playlist = true;
1782     ci.new_track = 1;
1783
1784     /* Officially playing */
1785     queue_reply(&audio_queue, 1);
1786
1787     audio_fill_file_buffer(false, 0);
1788 }
1789
1790 /* Called on manual track skip */
1791 static void audio_initiate_track_change(long direction)
1792 {
1793     logf("audio_initiate_track_change(%ld)", direction);
1794
1795     ci.new_track += direction;
1796     wps_offset -= direction;
1797     if (paused)
1798         skipped_during_pause = true;
1799 }
1800
1801 /* Called on manual dir skip */
1802 static void audio_initiate_dir_change(long direction)
1803 {
1804     dir_skip = true;
1805     ci.new_track = direction;
1806     if (paused)
1807         skipped_during_pause = true;
1808 }
1809
1810 /* Called when PCM track change is complete */
1811 static void audio_finalise_track_change(void)
1812 {
1813     logf("audio_finalise_track_change");
1814
1815     if (automatic_skip)
1816     {
1817         wps_offset = 0;
1818         automatic_skip = false;
1819
1820         /* Invalidate prevtrack_id3 */
1821         memset(othertrack_id3, 0, sizeof(struct mp3entry));
1822
1823         if (prev_ti && prev_ti->audio_hid < 0)
1824         {
1825             /* No audio left so we clear all the track info. */
1826             clear_track_info(prev_ti);
1827         }
1828     }
1829     send_event(PLAYBACK_EVENT_TRACK_CHANGE, thistrack_id3);
1830     playlist_update_resume_info(audio_current_track());
1831 }
1832
1833 /*
1834  * Layout audio buffer as follows - iram buffer depends on target:
1835  * [|SWAP:iram][|TALK]|FILE|GUARD|PCM|[SWAP:dram[|iram]|]
1836  */
1837 static void audio_reset_buffer(void)
1838 {
1839     /* see audio_get_recording_buffer if this is modified */
1840     logf("audio_reset_buffer");
1841
1842     /* If the setup of anything allocated before the file buffer is
1843        changed, do check the adjustments after the buffer_alloc call
1844        as it will likely be affected and need sliding over */
1845
1846     /* Initially set up file buffer as all space available */
1847     malloc_buf = audiobuf + talk_get_bufsize();
1848     /* Align the malloc buf to line size. Especially important to cf
1849        targets that do line reads/writes. */
1850     malloc_buf = (unsigned char *)(((uintptr_t)malloc_buf + 15) & ~15);
1851     filebuf    = malloc_buf; /* filebuf line align implied */
1852     filebuflen = audiobufend - filebuf;
1853
1854     filebuflen &= ~15;
1855
1856     /* Subtract whatever the pcm buffer says it used plus the guard buffer */
1857     const size_t pcmbuf_size = pcmbuf_init(filebuf + filebuflen) +GUARD_BUFSIZE;
1858
1859 #ifdef DEBUG
1860     if(pcmbuf_size > filebuflen)
1861         panicf("Not enough memory for pcmbuf_init() : %d > %d",
1862                 (int)pcmbuf_size, (int)filebuflen);
1863 #endif
1864
1865     filebuflen -= pcmbuf_size;
1866
1867     /* Make sure filebuflen is a longword multiple after adjustment - filebuf
1868        will already be line aligned */
1869     filebuflen &= ~3;
1870
1871     buffering_reset(filebuf, filebuflen);
1872
1873     /* Clear any references to the file buffer */
1874     buffer_state = AUDIOBUF_STATE_INITIALIZED;
1875
1876 #if defined(ROCKBOX_HAS_LOGF) && defined(LOGF_ENABLE)
1877     /* Make sure everything adds up - yes, some info is a bit redundant but
1878        aids viewing and the sumation of certain variables should add up to
1879        the location of others. */
1880     {
1881         size_t pcmbufsize;
1882         const unsigned char *pcmbuf = pcmbuf_get_meminfo(&pcmbufsize);
1883         logf("mabuf:  %08X", (unsigned)malloc_buf);
1884         logf("fbuf:   %08X", (unsigned)filebuf);
1885         logf("fbufe:  %08X", (unsigned)(filebuf + filebuflen));
1886         logf("gbuf:   %08X", (unsigned)(filebuf + filebuflen));
1887         logf("gbufe:  %08X", (unsigned)(filebuf + filebuflen + GUARD_BUFSIZE));
1888         logf("pcmb:   %08X", (unsigned)pcmbuf);
1889         logf("pcmbe:  %08X", (unsigned)(pcmbuf + pcmbufsize));
1890     }
1891 #endif
1892 }
1893
1894 static void audio_thread(void)
1895 {
1896     struct queue_event ev;
1897
1898     pcm_postinit();
1899
1900     audio_thread_ready = true;
1901
1902     while (1)
1903     {
1904         if (filling != STATE_FILLING && filling != STATE_IDLE) {
1905             /* End of buffering, let's calculate the watermark and unboost */
1906             set_filebuf_watermark();
1907             cancel_cpu_boost();
1908         }
1909
1910         if (!pcmbuf_queue_scan(&ev))
1911             queue_wait_w_tmo(&audio_queue, &ev, HZ/2);
1912
1913         switch (ev.id) {
1914
1915             case Q_AUDIO_FILL_BUFFER:
1916                 LOGFQUEUE("audio < Q_AUDIO_FILL_BUFFER %d", (int)ev.data);
1917                 audio_fill_file_buffer((bool)ev.data, 0);
1918                 break;
1919
1920             case Q_AUDIO_FINISH_LOAD:
1921                 LOGFQUEUE("audio < Q_AUDIO_FINISH_LOAD");
1922                 audio_finish_load_track();
1923                 buf_set_base_handle(CUR_TI->audio_hid);
1924                 break;
1925
1926             case Q_AUDIO_PLAY:
1927                 LOGFQUEUE("audio < Q_AUDIO_PLAY");
1928                 if (playing && ev.data <= 0)
1929                     audio_new_playlist();
1930                 else
1931                 {
1932                     audio_stop_playback();
1933                     audio_play_start((size_t)ev.data);
1934                 }
1935                 break;
1936
1937             case Q_AUDIO_STOP:
1938                 LOGFQUEUE("audio < Q_AUDIO_STOP");
1939                 if (playing)
1940                     audio_stop_playback();
1941                 if (ev.data != 0)
1942                     queue_clear(&audio_queue);
1943                 break;
1944
1945             case Q_AUDIO_PAUSE:
1946                 LOGFQUEUE("audio < Q_AUDIO_PAUSE");
1947                 if (!(bool) ev.data && skipped_during_pause
1948 #ifdef HAVE_CROSSFADE
1949                     && !pcmbuf_is_crossfade_active()
1950 #endif
1951                     )
1952                     pcmbuf_play_stop(); /* Flush old track on resume after skip */
1953                 skipped_during_pause = false;
1954                 if (!playing)
1955                     break;
1956                 pcmbuf_pause((bool)ev.data);
1957                 paused = (bool)ev.data;
1958                 break;
1959
1960             case Q_AUDIO_SKIP:
1961                 LOGFQUEUE("audio < Q_AUDIO_SKIP");
1962                 audio_initiate_track_change((long)ev.data);
1963                 break;
1964
1965             case Q_AUDIO_PRE_FF_REWIND:
1966                 LOGFQUEUE("audio < Q_AUDIO_PRE_FF_REWIND");
1967                 if (!playing)
1968                     break;
1969                 pcmbuf_pause(true);
1970                 break;
1971
1972             case Q_AUDIO_FF_REWIND:
1973                 LOGFQUEUE("audio < Q_AUDIO_FF_REWIND");
1974                 if (!playing)
1975                     break;
1976                 if (automatic_skip)
1977                 {
1978                     /* An automatic track skip is in progress. Finalize it,
1979                        then go back to the previous track */
1980                     audio_finalise_track_change();
1981                     ci.new_track = -1;
1982                 }
1983                 ci.seek_time = (long)ev.data+1;
1984                 break;
1985
1986             case Q_AUDIO_CHECK_NEW_TRACK:
1987                 LOGFQUEUE("audio < Q_AUDIO_CHECK_NEW_TRACK");
1988                 queue_reply(&audio_queue, audio_check_new_track());
1989                 break;
1990
1991             case Q_AUDIO_DIR_SKIP:
1992                 LOGFQUEUE("audio < Q_AUDIO_DIR_SKIP");
1993                 audio_initiate_dir_change(ev.data);
1994                 break;
1995
1996             case Q_AUDIO_FLUSH:
1997                 LOGFQUEUE("audio < Q_AUDIO_FLUSH");
1998                 audio_invalidate_tracks();
1999                 break;
2000
2001             case Q_AUDIO_TRACK_CHANGED:
2002                 /* PCM track change done */
2003                 LOGFQUEUE("audio < Q_AUDIO_TRACK_CHANGED");
2004                 audio_finalise_track_change();
2005                 break;
2006 #ifndef SIMULATOR
2007             case SYS_USB_CONNECTED:
2008                 LOGFQUEUE("audio < SYS_USB_CONNECTED");
2009                 if (playing)
2010                     audio_stop_playback();
2011 #ifdef PLAYBACK_VOICE
2012                 voice_stop();
2013 #endif
2014                 usb_acknowledge(SYS_USB_CONNECTED_ACK);
2015                 usb_wait_for_disconnect(&audio_queue);
2016
2017                 /* Mark all entries null. */
2018                 audio_clear_track_entries();
2019
2020                 /* release tracks to make sure all handles are closed */
2021                 audio_release_tracks();
2022                 break;
2023 #endif
2024
2025             case SYS_TIMEOUT:
2026                 LOGFQUEUE_SYS_TIMEOUT("audio < SYS_TIMEOUT");
2027                 break;
2028
2029             default:
2030                 /* LOGFQUEUE("audio < default : %08lX", ev.id); */
2031                 break;
2032         } /* end switch */
2033     } /* end while */
2034 }
2035
2036 /* Initialize the audio system - called from init() in main.c.
2037  * Last function because of all the references to internal symbols
2038  */
2039 void audio_init(void)
2040 {
2041     unsigned int audio_thread_id;
2042
2043     /* Can never do this twice */
2044     if (audio_is_initialized)
2045     {
2046         logf("audio: already initialized");
2047         return;
2048     }
2049
2050     logf("audio: initializing");
2051
2052     /* Initialize queues before giving control elsewhere in case it likes
2053        to send messages. Thread creation will be delayed however so nothing
2054        starts running until ready if something yields such as talk_init. */
2055     queue_init(&audio_queue, true);
2056     queue_init(&codec_queue, false);
2057     queue_init(&pcmbuf_queue, false);
2058
2059     pcm_init();
2060
2061     codec_init_codec_api();
2062
2063     thistrack_id3 = &mp3entry_buf[0];
2064     othertrack_id3 = &mp3entry_buf[1];
2065
2066     /* cuesheet support */
2067     if (global_settings.cuesheet)
2068         curr_cue = (struct cuesheet*)buffer_alloc(sizeof(struct cuesheet));
2069
2070     /* initialize the buffer */
2071     filebuf = audiobuf;
2072
2073     /* audio_reset_buffer must to know the size of voice buffer so init
2074        talk first */
2075     talk_init();
2076
2077     make_codec_thread();
2078
2079     audio_thread_id = create_thread(audio_thread, audio_stack,
2080                   sizeof(audio_stack), CREATE_THREAD_FROZEN,
2081                   audio_thread_name IF_PRIO(, PRIORITY_USER_INTERFACE)
2082                   IF_COP(, CPU));
2083
2084     queue_enable_queue_send(&audio_queue, &audio_queue_sender_list,
2085                             audio_thread_id);
2086
2087 #ifdef PLAYBACK_VOICE
2088     voice_thread_init();
2089 #endif
2090
2091 #ifdef HAVE_CROSSFADE
2092     /* Set crossfade setting for next buffer init which should be about... */
2093     pcmbuf_request_crossfade_enable(global_settings.crossfade);
2094 #endif
2095
2096     /* initialize the buffering system */
2097
2098     buffering_init();
2099     /* ...now! Set up the buffers */
2100     audio_reset_buffer();
2101
2102     int i;
2103     for(i = 0; i < MAX_TRACK; i++)
2104     {
2105         tracks[i].audio_hid = -1;
2106         tracks[i].id3_hid = -1;
2107         tracks[i].codec_hid = -1;
2108         tracks[i].cuesheet_hid = -1;
2109     }
2110 #ifdef HAVE_ALBUMART
2111     FOREACH_ALBUMART(i)
2112     {
2113         int j;
2114         for (j = 0; j < MAX_TRACK; j++)
2115         {
2116             tracks[j].aa_hid[i] = -1;
2117         }
2118     }
2119 #endif
2120
2121     add_event(BUFFER_EVENT_REBUFFER, false, buffering_handle_rebuffer_callback);
2122     add_event(BUFFER_EVENT_FINISHED, false, buffering_handle_finished_callback);
2123
2124     /* Probably safe to say */
2125     audio_is_initialized = true;
2126
2127     sound_settings_apply();
2128 #ifdef HAVE_DISK_STORAGE
2129     audio_set_buffer_margin(global_settings.buffer_margin);
2130 #endif
2131
2132     /* it's safe to let the threads run now */
2133 #ifdef PLAYBACK_VOICE
2134     voice_thread_resume();
2135 #endif
2136     thread_thaw(codec_thread_id);
2137     thread_thaw(audio_thread_id);
2138
2139 } /* audio_init */
2140
2141 bool audio_is_thread_ready(void)
2142 {
2143     return audio_thread_ready;
2144 }
2145
2146 size_t audio_get_filebuflen(void)
2147 {
2148     return filebuflen;
2149 }
2150
2151 int get_audio_hid()
2152 {
2153     return CUR_TI->audio_hid;
2154 }
2155
2156 int *get_codec_hid()
2157 {
2158     return &tracks[track_ridx].codec_hid;
2159 }