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