apps/playback.c

   1 /***************************************************************************
   2  *             __________               __   ___.
   3  *   Open      \______   \ ____   ____ |  | _\_ |__   _______  ___
   4  *   Source     |       _//  _ \_/ ___\|  |/ /| __ \ /  _ \  \/  /
   5  *   Jukebox    |    |   (  <_> )  \___|    < | \_\ (  <_> > <  <
   6  *   Firmware   |____|_  /\____/ \___  >__|_ \|___  /\____/__/\_ \
   7  *                     \/            \/     \/    \/            \/
   8  * $Id$
   9  *
  10  * Copyright (C) 2005 Miika Pekkarinen
  11  *
  12  * All files in this archive are subject to the GNU General Public License.
  13  * See the file COPYING in the source tree root for full license agreement.
  14  *
  15  * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY
  16  * KIND, either express or implied.
  17  *
  18  ****************************************************************************/
  19
  20 /* TODO: Can use the track changed callback to detect end of track and seek
  21  * in the previous track until this happens */
  22 /* Design: we have prev_ti already, have a conditional for what type of seek
  23  * to do on a seek request, if it is a previous track seek, skip previous,
  24  * and in the request_next_track callback set the offset up the same way that
  25  * starting from an offset works. */
  26 /* TODO: Pause should be handled in here, rather than PCMBUF so that voice can
  27  * play whilst audio is paused */
  28
  29 #include <stdio.h>
  30 #include <string.h>
  31 #include <stdlib.h>
  32 #include <ctype.h>
  33
  34 #include "system.h"
  35 #include "thread.h"
  36 #include "file.h"
  37 #include "panic.h"
  38 #include "memory.h"
  39 #include "lcd.h"
  40 #include "font.h"
  41 #include "button.h"
  42 #include "kernel.h"
  43 #include "tree.h"
  44 #include "debug.h"
  45 #include "sprintf.h"
  46 #include "settings.h"
  47 #include "codecs.h"
  48 #include "audio.h"
  49 #include "buffering.h"
  50 #include "mp3_playback.h"
  51 #include "usb.h"
  52 #include "status.h"
  53 #include "ata.h"
  54 #include "screens.h"
  55 #include "playlist.h"
  56 #include "playback.h"
  57 #include "pcmbuf.h"
  58 #include "buffer.h"
  59 #include "dsp.h"
  60 #include "abrepeat.h"
  61 #include "cuesheet.h"
  62 #ifdef HAVE_TAGCACHE
  63 #include "tagcache.h"
  64 #endif
  65 #ifdef HAVE_LCD_BITMAP
  66 #include "icons.h"
  67 #include "peakmeter.h"
  68 #include "action.h"
  69 #endif
  70 #include "lang.h"
  71 #include "bookmark.h"
  72 #include "misc.h"
  73 #include "sound.h"
  74 #include "metadata.h"
  75 #include "splash.h"
  76 #include "talk.h"
  77 #include "ata_idle_notify.h"
  78
  79 #ifdef HAVE_RECORDING
  80 #include "recording.h"
  81 #include "talk.h"
  82 #endif
  83
  84 #ifdef HAVE_WM8758
  85 #include "menus/eq_menu.h"
  86 #endif
  87
  88 #define PLAYBACK_VOICE
  89
  90
  91 /* default point to start buffer refill */
  92 #define AUDIO_DEFAULT_WATERMARK      (1024*512)
  93 /* amount of data to read in one read() call */
  94 #define AUDIO_DEFAULT_FILECHUNK      (1024*32)
  95 /* point at which the file buffer will fight for CPU time */
  96 #define AUDIO_FILEBUF_CRITICAL       (1024*128)
  97 /* amount of guess-space to allow for codecs that must hunt and peck
  98  * for their correct seeek target, 32k seems a good size */
  99 #define AUDIO_REBUFFER_GUESS_SIZE    (1024*32)
 100
 101 /* Define LOGF_ENABLE to enable logf output in this file */
 102 /*#define LOGF_ENABLE*/
 103 #include "logf.h"
 104
 105 /* macros to enable logf for queues
 106    logging on SYS_TIMEOUT can be disabled */
 107 #ifdef SIMULATOR
 108 /* Define this for logf output of all queuing except SYS_TIMEOUT */
 109 #define PLAYBACK_LOGQUEUES
 110 /* Define this to logf SYS_TIMEOUT messages */
 111 /*#define PLAYBACK_LOGQUEUES_SYS_TIMEOUT*/
 112 #endif
 113
 114 #ifdef PLAYBACK_LOGQUEUES
 115 #define LOGFQUEUE logf
 116 #else
 117 #define LOGFQUEUE(...)
 118 #endif
 119
 120 #ifdef PLAYBACK_LOGQUEUES_SYS_TIMEOUT
 121 #define LOGFQUEUE_SYS_TIMEOUT logf
 122 #else
 123 #define LOGFQUEUE_SYS_TIMEOUT(...)
 124 #endif
 125
 126
 127 /* Define one constant that includes recording related functionality */
 128 #if defined(HAVE_RECORDING) && !defined(SIMULATOR)
 129 #define AUDIO_HAVE_RECORDING
 130 #endif
 131
 132 enum {
 133     Q_AUDIO_PLAY = 1,
 134     Q_AUDIO_STOP,
 135     Q_AUDIO_PAUSE,
 136     Q_AUDIO_SKIP,
 137     Q_AUDIO_PRE_FF_REWIND,
 138     Q_AUDIO_FF_REWIND,
 139     Q_AUDIO_REBUFFER_SEEK,
 140     Q_AUDIO_CHECK_NEW_TRACK,
 141     Q_AUDIO_FLUSH,
 142     Q_AUDIO_TRACK_CHANGED,
 143     Q_AUDIO_DIR_SKIP,
 144     Q_AUDIO_POSTINIT,
 145     Q_AUDIO_FILL_BUFFER,
 146 #if MEM > 8
 147     Q_AUDIO_FILL_BUFFER_IF_ACTIVE_ATA,
 148 #endif
 149     Q_CODEC_REQUEST_COMPLETE,
 150     Q_CODEC_REQUEST_FAILED,
 151
 152     Q_VOICE_PLAY,
 153     Q_VOICE_STOP,
 154
 155     Q_CODEC_LOAD,
 156     Q_CODEC_LOAD_DISK,
 157
 158 #ifdef AUDIO_HAVE_RECORDING
 159     Q_ENCODER_LOAD_DISK,
 160     Q_ENCODER_RECORD,
 161 #endif
 162 };
 163
 164 /* As defined in plugins/lib/xxx2wav.h */
 165 #if MEM > 1
 166 #define MALLOC_BUFSIZE (512*1024)
 167 #define GUARD_BUFSIZE  (32*1024)
 168 #else
 169 #define MALLOC_BUFSIZE (100*1024)
 170 #define GUARD_BUFSIZE  (8*1024)
 171 #endif
 172
 173 /* As defined in plugin.lds */
 174 #if defined(CPU_PP)
 175 #define CODEC_IRAM_ORIGIN   ((unsigned char *)0x4000c000)
 176 #define CODEC_IRAM_SIZE     ((size_t)0xc000)
 177 #elif defined(IAUDIO_X5) || defined(IAUDIO_M5)
 178 #define CODEC_IRAM_ORIGIN   ((unsigned char *)0x10010000)
 179 #define CODEC_IRAM_SIZE     ((size_t)0x10000)
 180 #else
 181 #define CODEC_IRAM_ORIGIN   ((unsigned char *)0x1000c000)
 182 #define CODEC_IRAM_SIZE     ((size_t)0xc000)
 183 #endif
 184
 185 #ifndef IBSS_ATTR_VOICE_STACK
 186 #define IBSS_ATTR_VOICE_STACK IBSS_ATTR
 187 #endif
 188
 189 bool audio_is_initialized = false;
 190
 191 /* Variables are commented with the threads that use them: *
 192  * A=audio, C=codec, V=voice. A suffix of - indicates that *
 193  * the variable is read but not updated on that thread.    */
 194 /* TBD: Split out "audio" and "playback" (ie. calling) threads */
 195
 196 /* Main state control */
 197 static volatile bool audio_codec_loaded NOCACHEBSS_ATTR = false; /* Codec loaded? (C/A-) */
 198 static volatile bool playing NOCACHEBSS_ATTR = false; /* Is audio playing? (A) */
 199 static volatile bool paused NOCACHEBSS_ATTR = false; /* Is audio paused? (A/C-) */
 200 static volatile bool filling IDATA_ATTR = false; /* Is file buffer refilling? (A/C-) */
 201
 202 /* Ring buffer where compressed audio and codecs are loaded */
 203 static unsigned char *filebuf = NULL;       /* Start of buffer (A/C-) */
 204 static unsigned char *malloc_buf = NULL;    /* Start of malloc buffer (A/C-) */
 205 /* FIXME: make filebuflen static */
 206 size_t filebuflen = 0;                      /* Size of buffer (A/C-) */
 207 /* FIXME: make buf_ridx (C/A-) */
 208
 209 /* Possible arrangements of the buffer */
 210 #define BUFFER_STATE_TRASHED        -1          /* trashed; must be reset */
 211 #define BUFFER_STATE_INITIALIZED     0          /* voice+audio OR audio-only */
 212 #define BUFFER_STATE_VOICED_ONLY     1          /* voice-only */
 213 static int buffer_state = BUFFER_STATE_TRASHED; /* Buffer state */
 214
 215 struct mp3entry curtrack_id3;
 216 struct mp3entry nexttrack_id3;
 217
 218 /* Track info structure about songs in the file buffer (A/C-) */
 219 struct track_info {
 220     int audio_hid;             /* The ID for the track's buffer handle */
 221     int id3_hid;               /* The ID for the track's metadata handle */
 222     int codec_hid;             /* The ID for the track's codec handle */
 223
 224     size_t codecsize;          /* Codec length in bytes */
 225     size_t filesize;           /* File total length */
 226
 227     bool taginfo_ready;        /* Is metadata read */
 228
 229     bool event_sent;           /* Was this track's buffered event sent */
 230 };
 231
 232 static struct track_info tracks[MAX_TRACK];
 233 static volatile int track_ridx = 0;  /* Track being decoded (A/C-) */
 234 static int track_widx = 0;           /* Track being buffered (A) */
 235
 236 static struct track_info *prev_ti = NULL; /* Previous track info pointer (A/C-) */
 237 #define CUR_TI (&tracks[track_ridx]) /* Playing track info pointer (A/C-) */
 238
 239 /* Set by the audio thread when the current track information has updated
 240  * and the WPS may need to update its cached information */
 241 static bool track_changed = false;
 242
 243 /* Information used only for filling the buffer */
 244 /* Playlist steps from playing track to next track to be buffered (A) */
 245 static int last_peek_offset = 0;
 246
 247 /* Scrobbler support */
 248 static unsigned long prev_track_elapsed = 0; /* Previous track elapsed time (C/A-)*/
 249
 250 /* Track change controls */
 251 static bool automatic_skip = false; /* Who initiated in-progress skip? (C/A-) */
 252 static bool playlist_end = false;   /* Has the current playlist ended? (A) */
 253 static bool dir_skip = false;       /* Is a directory skip pending? (A) */
 254 static bool new_playlist = false;   /* Are we starting a new playlist? (A) */
 255 static int wps_offset = 0;          /* Pending track change offset, to keep WPS responsive (A) */
 256 static bool skipped_during_pause = false; /* Do we need to clear the PCM buffer when playback resumes (A) */
 257
 258 /* Callbacks which applications or plugins may set */
 259 /* When the playing track has changed from the user's perspective */
 260 void (*track_changed_callback)(struct mp3entry *id3) = NULL;
 261 /* When a track has been buffered */
 262 void (*track_buffer_callback)(struct mp3entry *id3, bool last_track) = NULL;
 263 /* When a track's buffer has been overwritten or cleared */
 264 void (*track_unbuffer_callback)(struct mp3entry *id3, bool last_track) = NULL;
 265
 266 /* Configuration */
 267 static size_t conf_watermark = 0; /* Level to trigger filebuf fill (A/C) FIXME */
 268 static size_t conf_filechunk = 0; /* Largest chunk the codec accepts (A/C) FIXME */
 269 static size_t conf_preseek   = 0; /* Codec pre-seek margin (A/C) FIXME */
 270 static size_t buffer_margin  = 0; /* Buffer margin aka anti-skip buffer (A/C-) */
 271 #if MEM > 8
 272 static size_t high_watermark = 0; /* High watermark for rebuffer (A/V/other) */
 273 #endif
 274
 275 /* Multiple threads */
 276 static void set_current_codec(int codec_idx);
 277 /* Set the watermark to trigger buffer fill (A/C) FIXME */
 278 static void set_filebuf_watermark(int seconds);
 279
 280 /* Audio thread */
 281 static struct event_queue       audio_queue NOCACHEBSS_ATTR;
 282 static struct queue_sender_list audio_queue_sender_list NOCACHEBSS_ATTR;
 283 static long audio_stack[(DEFAULT_STACK_SIZE + 0x1000)/sizeof(long)];
 284 static const char audio_thread_name[] = "audio";
 285
 286 static void audio_thread(void);
 287 static void audio_initiate_track_change(long direction);
 288 static bool audio_have_tracks(void);
 289 static void audio_reset_buffer(void);
 290
 291 /* Codec thread */
 292 extern struct codec_api ci;
 293 static struct event_queue codec_queue NOCACHEBSS_ATTR;
 294 static long codec_stack[(DEFAULT_STACK_SIZE + 0x2000)/sizeof(long)]
 295 IBSS_ATTR;
 296 static const char codec_thread_name[] = "codec";
 297 struct thread_entry *codec_thread_p; /* For modifying thread priority later. */
 298
 299 static volatile int current_codec IDATA_ATTR; /* Current codec (normal/voice) */
 300
 301 /* Buffering thread */
 302 void buffering_thread(void);
 303 static long buffering_stack[(DEFAULT_STACK_SIZE + 0x2000)/sizeof(long)];
 304 static const char buffering_thread_name[] = "buffering";
 305 struct thread_entry *buffering_thread_p;
 306
 307 /* Voice thread */
 308 #ifdef PLAYBACK_VOICE
 309
 310 extern struct codec_api ci_voice;
 311
 312 static struct thread_entry *voice_thread_p = NULL;
 313 static struct event_queue voice_queue NOCACHEBSS_ATTR;
 314 static long voice_stack[(DEFAULT_STACK_SIZE + 0x2000)/sizeof(long)]
 315 IBSS_ATTR_VOICE_STACK;
 316 static const char voice_thread_name[] = "voice codec";
 317
 318 /* Voice codec swapping control */
 319 extern unsigned char codecbuf[];                /* DRAM codec swap buffer */
 320
 321 #ifdef SIMULATOR
 322 /* IRAM codec swap buffer for sim*/
 323 static unsigned char sim_iram[CODEC_IRAM_SIZE];
 324 #undef CODEC_IRAM_ORIGIN
 325 #define CODEC_IRAM_ORIGIN sim_iram
 326 #endif
 327
 328 /* iram_buf and dram_buf are either both NULL or both non-NULL */
 329 /* Pointer to IRAM buffer for codec swapping */
 330 static unsigned char *iram_buf = NULL;
 331 /* Pointer to DRAM buffer for codec swapping */
 332 static unsigned char *dram_buf = NULL;
 333 /* Parity of swap_codec calls - needed because one codec swapping itself in
 334    automatically swaps in the other and the swap when unlocking should not
 335    happen if the parity is even.
 336  */
 337 static bool   swap_codec_parity NOCACHEBSS_ATTR = false; /* true=odd, false=even */
 338 /* Locking to control which codec (normal/voice) is running */
 339 static struct semaphore sem_codecthread NOCACHEBSS_ATTR;
 340 static struct event event_codecthread NOCACHEBSS_ATTR;
 341
 342 /* Voice state */
 343 static volatile bool voice_thread_start = false; /* Triggers voice playback (A/V) */
 344 static volatile bool voice_is_playing NOCACHEBSS_ATTR = false; /* Is voice currently playing? (V) */
 345 static volatile bool voice_codec_loaded NOCACHEBSS_ATTR = false; /* Is voice codec loaded (V/A-) */
 346 static unsigned char *voicebuf = NULL;
 347 static size_t voice_remaining = 0;
 348
 349 #ifdef IRAM_STEAL
 350 /* Voice IRAM has been stolen for other use */
 351 static bool voice_iram_stolen = false;
 352 #endif
 353
 354 static void (*voice_getmore)(unsigned char** start, size_t* size) = NULL;
 355
 356 struct voice_info {
 357     void (*callback)(unsigned char **start, size_t* size);
 358     size_t size;
 359     unsigned char *buf;
 360 };
 361 static void voice_thread(void);
 362 static void voice_stop(void);
 363
 364 #endif /* PLAYBACK_VOICE */
 365
 366
 367 /* --- Helper functions --- */
 368
 369 struct mp3entry *bufgetid3(int handle_id)
 370 {
 371     struct mp3entry *id3;
 372     ssize_t ret = bufgetdata(handle_id, 0, (unsigned char **)&id3);
 373
 374     if (ret < 0 || ret != sizeof(struct mp3entry))
 375         return NULL;
 376
 377     return id3;
 378 }
 379
 380 /* --- External interfaces --- */
 381
 382 void mp3_play_data(const unsigned char* start, int size,
 383                    void (*get_more)(unsigned char** start, size_t* size))
 384 {
 385 #ifdef PLAYBACK_VOICE
 386     static struct voice_info voice_clip;
 387     voice_clip.callback = get_more;
 388     voice_clip.buf = (unsigned char*)start;
 389     voice_clip.size = size;
 390     LOGFQUEUE("mp3 > voice Q_VOICE_STOP");
 391     queue_post(&voice_queue, Q_VOICE_STOP, 0);
 392     LOGFQUEUE("mp3 > voice Q_VOICE_PLAY");
 393     queue_post(&voice_queue, Q_VOICE_PLAY, (intptr_t)&voice_clip);
 394     voice_thread_start = true;
 395     trigger_cpu_boost();
 396 #else
 397     (void) start;
 398     (void) size;
 399     (void) get_more;
 400 #endif
 401 }
 402
 403 void mp3_play_stop(void)
 404 {
 405 #ifdef PLAYBACK_VOICE
 406     queue_remove_from_head(&voice_queue, Q_VOICE_STOP);
 407     LOGFQUEUE("mp3 > voice Q_VOICE_STOP");
 408     queue_post(&voice_queue, Q_VOICE_STOP, 1);
 409 #endif
 410 }
 411
 412 void mp3_play_pause(bool play)
 413 {
 414     /* a dummy */
 415     (void)play;
 416 }
 417
 418 bool mp3_is_playing(void)
 419 {
 420 #ifdef PLAYBACK_VOICE
 421     return voice_is_playing;
 422 #else
 423     return false;
 424 #endif
 425 }
 426
 427 /* If voice could be swapped out - wait for it to return
 428  * Used by buffer claming functions.
 429  */
 430 static void wait_for_voice_swap_in(void)
 431 {
 432 #ifdef PLAYBACK_VOICE
 433     if (NULL == iram_buf)
 434         return;
 435
 436     event_wait(&event_codecthread, STATE_NONSIGNALED);
 437 #endif /* PLAYBACK_VOICE */
 438 }
 439
 440 /* This sends a stop message and the audio thread will dump all it's
 441    subsequenct messages */
 442 static void audio_hard_stop(void)
 443 {
 444     /* Stop playback */
 445     LOGFQUEUE("audio >| audio Q_AUDIO_STOP: 1");
 446     queue_send(&audio_queue, Q_AUDIO_STOP, 1);
 447 }
 448
 449 unsigned char *audio_get_buffer(bool talk_buf, size_t *buffer_size)
 450 {
 451     unsigned char *buf, *end;
 452
 453     if (audio_is_initialized)
 454     {
 455         audio_hard_stop();
 456         wait_for_voice_swap_in();
 457 #ifdef PLAYBACK_VOICE
 458         voice_stop();
 459 #endif
 460     }
 461     /* else buffer_state will be BUFFER_STATE_TRASHED at this point */
 462
 463     if (buffer_size == NULL)
 464     {
 465         /* Special case for talk_init to use since it already knows it's
 466            trashed */
 467         buffer_state = BUFFER_STATE_TRASHED;
 468         return NULL;
 469     }
 470
 471     if (talk_buf || buffer_state == BUFFER_STATE_TRASHED
 472            || !talk_voice_required())
 473     {
 474         logf("get buffer: talk, audio");
 475         /* Ok to use everything from audiobuf to audiobufend - voice is loaded,
 476            the talk buffer is not needed because voice isn't being used, or
 477            could be BUFFER_STATE_TRASHED already. If state is
 478            BUFFER_STATE_VOICED_ONLY, no problem as long as memory isn't written
 479            without the caller knowing what's going on. Changing certain settings
 480            may move it to a worse condition but the memory in use by something
 481            else will remain undisturbed.
 482          */
 483         if (buffer_state != BUFFER_STATE_TRASHED)
 484         {
 485             talk_buffer_steal();
 486             buffer_state = BUFFER_STATE_TRASHED;
 487         }
 488
 489         buf = audiobuf;
 490         end = audiobufend;
 491     }
 492     else
 493     {
 494         /* Safe to just return this if already BUFFER_STATE_VOICED_ONLY or
 495            still BUFFER_STATE_INITIALIZED */
 496         /* Skip talk buffer and move pcm buffer to end to maximize available
 497            contiguous memory - no audio running means voice will not need the
 498            swap space */
 499         logf("get buffer: audio");
 500         buf = audiobuf + talk_get_bufsize();
 501         end = audiobufend - pcmbuf_init(audiobufend);
 502         buffer_state = BUFFER_STATE_VOICED_ONLY;
 503     }
 504
 505     *buffer_size = end - buf;
 506
 507     return buf;
 508 }
 509
 510 #ifdef IRAM_STEAL
 511 void audio_iram_steal(void)
 512 {
 513     /* We need to stop audio playback in order to use codec IRAM */
 514     audio_hard_stop();
 515
 516 #ifdef PLAYBACK_VOICE
 517     if (NULL != iram_buf)
 518     {
 519         /* Can't already be stolen */
 520         if (voice_iram_stolen)
 521             return;
 522
 523         /* Must wait for voice to be current again if it is swapped which
 524            would cause the caller's buffer to get clobbered when voice locks
 525            and runs - we'll wait for it to lock and yield again then make sure
 526            the ride has come to a complete stop */
 527         wait_for_voice_swap_in();
 528         voice_stop();
 529
 530         /* Save voice IRAM but just memcpy - safe to do here since voice
 531            is current and no audio codec is loaded */
 532         memcpy(iram_buf, CODEC_IRAM_ORIGIN, CODEC_IRAM_SIZE);
 533         voice_iram_stolen = true;
 534     }
 535     else
 536     {
 537         /* Nothing much to do if no voice */
 538         voice_iram_stolen = false;
 539     }
 540 #endif
 541 }
 542 #endif /* IRAM_STEAL */
 543
 544 #ifdef HAVE_RECORDING
 545 unsigned char *audio_get_recording_buffer(size_t *buffer_size)
 546 {
 547     /* Don't allow overwrite of voice swap area or we'll trash the
 548        swapped-out voice codec but can use whole thing if none */
 549     unsigned char *end;
 550
 551     /* Stop audio and voice. Wait for voice to swap in and be clear
 552        of pending events to ensure trouble-free operation of encoders */
 553     audio_hard_stop();
 554     wait_for_voice_swap_in();
 555 #ifdef PLAYBACK_VOICE
 556     voice_stop();
 557 #endif
 558     talk_buffer_steal();
 559
 560 #ifdef PLAYBACK_VOICE
 561     /* If no dram_buf, swap space not used and recording gets more
 562        memory. Codec swap areas will remain unaffected by the next init
 563        since they're allocated at the end of the buffer and their sizes
 564        don't change between calls */
 565     end = dram_buf;
 566     if (NULL == end)
 567 #endif /* PLAYBACK_VOICE */
 568         end = audiobufend;
 569
 570     buffer_state = BUFFER_STATE_TRASHED;
 571
 572     *buffer_size = end - audiobuf;
 573
 574     return (unsigned char *)audiobuf;
 575 }
 576
 577 bool audio_load_encoder(int afmt)
 578 {
 579 #ifndef SIMULATOR
 580     const char *enc_fn = get_codec_filename(afmt | CODEC_TYPE_ENCODER);
 581     if (!enc_fn)
 582         return false;
 583
 584     audio_remove_encoder();
 585     ci.enc_codec_loaded = 0; /* clear any previous error condition */
 586
 587     LOGFQUEUE("codec > Q_ENCODER_LOAD_DISK");
 588     queue_post(&codec_queue, Q_ENCODER_LOAD_DISK, (intptr_t)enc_fn);
 589
 590     while (ci.enc_codec_loaded == 0)
 591         yield();
 592
 593     logf("codec loaded: %d", ci.enc_codec_loaded);
 594
 595     return ci.enc_codec_loaded > 0;
 596 #else
 597     (void)afmt;
 598     return true;
 599 #endif
 600 } /* audio_load_encoder */
 601
 602 void audio_remove_encoder(void)
 603 {
 604 #ifndef SIMULATOR
 605     /* force encoder codec unload (if currently loaded) */
 606     if (ci.enc_codec_loaded <= 0)
 607         return;
 608
 609     ci.stop_encoder = true;
 610     while (ci.enc_codec_loaded > 0)
 611         yield();
 612 #endif
 613 } /* audio_remove_encoder */
 614
 615 #endif /* HAVE_RECORDING */
 616
 617 struct mp3entry* audio_current_track(void)
 618 {
 619     const char *filename;
 620     const char *p;
 621     static struct mp3entry temp_id3;
 622     int cur_idx;
 623     int offset = ci.new_track + wps_offset;
 624
 625     cur_idx = track_ridx + offset;
 626     cur_idx &= MAX_TRACK_MASK;
 627
 628     if (tracks[cur_idx].id3_hid > 0)
 629         return bufgetid3(tracks[cur_idx].id3_hid);
 630
 631     memset(&temp_id3, 0, sizeof(struct mp3entry));
 632
 633     filename = playlist_peek(0);
 634     if (!filename)
 635         filename = "No file!";
 636
 637 #ifdef HAVE_TC_RAMCACHE
 638     if (tagcache_fill_tags(&temp_id3, filename))
 639         return &temp_id3;
 640 #endif
 641
 642     p = strrchr(filename, '/');
 643     if (!p)
 644         p = filename;
 645     else
 646         p++;
 647
 648     strncpy(temp_id3.path, p, sizeof(temp_id3.path)-1);
 649     temp_id3.title = &temp_id3.path[0];
 650
 651     return &temp_id3;
 652 }
 653
 654 struct mp3entry* audio_next_track(void)
 655 {
 656     int next_idx = track_ridx;
 657
 658     if (!audio_have_tracks())
 659         return NULL;
 660
 661     next_idx++;
 662     next_idx &= MAX_TRACK_MASK;
 663
 664     if (tracks[next_idx].id3_hid <= 0)
 665         return NULL;
 666
 667     return bufgetid3(tracks[next_idx].id3_hid);
 668 }
 669
 670 bool audio_has_changed_track(void)
 671 {
 672     if (track_changed)
 673     {
 674         track_changed = false;
 675         return true;
 676     }
 677
 678     return false;
 679 }
 680
 681 void audio_play(long offset)
 682 {
 683     logf("audio_play");
 684
 685 #ifdef PLAYBACK_VOICE
 686     /* Truncate any existing voice output so we don't have spelling
 687      * etc. over the first part of the played track */
 688     talk_force_shutup();
 689 #endif
 690
 691     /* Start playback */
 692     LOGFQUEUE("audio >| audio Q_AUDIO_PLAY: %ld", offset);
 693     /* Don't return until playback has actually started */
 694     queue_send(&audio_queue, Q_AUDIO_PLAY, offset);
 695 }
 696
 697 void audio_stop(void)
 698 {
 699     /* Stop playback */
 700     LOGFQUEUE("audio >| audio Q_AUDIO_STOP");
 701     /* Don't return until playback has actually stopped */
 702     queue_send(&audio_queue, Q_AUDIO_STOP, 0);
 703 }
 704
 705 void audio_pause(void)
 706 {
 707     LOGFQUEUE("audio >| audio Q_AUDIO_PAUSE");
 708     /* Don't return until playback has actually paused */
 709     queue_send(&audio_queue, Q_AUDIO_PAUSE, true);
 710 }
 711
 712 void audio_resume(void)
 713 {
 714     LOGFQUEUE("audio >| audio Q_AUDIO_PAUSE resume");
 715     /* Don't return until playback has actually resumed */
 716     queue_send(&audio_queue, Q_AUDIO_PAUSE, false);
 717 }
 718
 719 void audio_next(void)
 720 {
 721     if (playlist_check(ci.new_track + wps_offset + 1))
 722     {
 723         if (global_settings.beep)
 724             pcmbuf_beep(5000, 100, 2500*global_settings.beep);
 725
 726         LOGFQUEUE("audio > audio Q_AUDIO_SKIP 1");
 727         queue_post(&audio_queue, Q_AUDIO_SKIP, 1);
 728         /* Update wps while our message travels inside deep playback queues. */
 729         wps_offset++;
 730         track_changed = true;
 731     }
 732     else
 733     {
 734         /* No more tracks. */
 735         if (global_settings.beep)
 736             pcmbuf_beep(1000, 100, 1000*global_settings.beep);
 737     }
 738 }
 739
 740 void audio_prev(void)
 741 {
 742     if (playlist_check(ci.new_track + wps_offset - 1))
 743     {
 744         if (global_settings.beep)
 745             pcmbuf_beep(5000, 100, 2500*global_settings.beep);
 746
 747         LOGFQUEUE("audio > audio Q_AUDIO_SKIP -1");
 748         queue_post(&audio_queue, Q_AUDIO_SKIP, -1);
 749         /* Update wps while our message travels inside deep playback queues. */
 750         wps_offset--;
 751         track_changed = true;
 752     }
 753     else
 754     {
 755         /* No more tracks. */
 756         if (global_settings.beep)
 757             pcmbuf_beep(1000, 100, 1000*global_settings.beep);
 758     }
 759 }
 760
 761 void audio_next_dir(void)
 762 {
 763     LOGFQUEUE("audio > audio Q_AUDIO_DIR_SKIP 1");
 764     queue_post(&audio_queue, Q_AUDIO_DIR_SKIP, 1);
 765 }
 766
 767 void audio_prev_dir(void)
 768 {
 769     LOGFQUEUE("audio > audio Q_AUDIO_DIR_SKIP -1");
 770     queue_post(&audio_queue, Q_AUDIO_DIR_SKIP, -1);
 771 }
 772
 773 void audio_pre_ff_rewind(void)
 774 {
 775     LOGFQUEUE("audio > audio Q_AUDIO_PRE_FF_REWIND");
 776     queue_post(&audio_queue, Q_AUDIO_PRE_FF_REWIND, 0);
 777 }
 778
 779 void audio_ff_rewind(long newpos)
 780 {
 781     LOGFQUEUE("audio > audio Q_AUDIO_FF_REWIND");
 782     queue_post(&audio_queue, Q_AUDIO_FF_REWIND, newpos);
 783 }
 784
 785 void audio_flush_and_reload_tracks(void)
 786 {
 787     LOGFQUEUE("audio > audio Q_AUDIO_FLUSH");
 788     queue_post(&audio_queue, Q_AUDIO_FLUSH, 0);
 789 }
 790
 791 void audio_error_clear(void)
 792 {
 793 #ifdef AUDIO_HAVE_RECORDING
 794     pcm_rec_error_clear();
 795 #endif
 796 }
 797
 798 int audio_status(void)
 799 {
 800     int ret = 0;
 801
 802     if (playing)
 803         ret |= AUDIO_STATUS_PLAY;
 804
 805     if (paused)
 806         ret |= AUDIO_STATUS_PAUSE;
 807
 808 #ifdef HAVE_RECORDING
 809     /* Do this here for constitency with mpeg.c version */
 810     ret |= pcm_rec_status();
 811 #endif
 812
 813     return ret;
 814 }
 815
 816 int audio_get_file_pos(void)
 817 {
 818     return 0;
 819 }
 820
 821 #ifndef HAVE_FLASH_STORAGE
 822 void audio_set_buffer_margin(int setting)
 823 {
 824     static const int lookup[] = {5, 15, 30, 60, 120, 180, 300, 600};
 825     buffer_margin = lookup[setting];
 826     logf("buffer margin: %ld", buffer_margin);
 827     set_filebuf_watermark(buffer_margin);
 828 }
 829 #endif
 830
 831 /* Take nescessary steps to enable or disable the crossfade setting */
 832 void audio_set_crossfade(int enable)
 833 {
 834     size_t offset;
 835     bool was_playing;
 836     size_t size;
 837
 838     /* Tell it the next setting to use */
 839     pcmbuf_crossfade_enable(enable);
 840
 841     /* Return if size hasn't changed or this is too early to determine
 842        which in the second case there's no way we could be playing
 843        anything at all */
 844     if (pcmbuf_is_same_size())
 845     {
 846         /* This function is a copout and just syncs some variables -
 847            to be removed at a later date */
 848         pcmbuf_crossfade_enable_finished();
 849         return;
 850     }
 851
 852     offset = 0;
 853     was_playing = playing;
 854
 855     /* Playback has to be stopped before changing the buffer size */
 856     if (was_playing)
 857     {
 858         /* Store the track resume position */
 859         offset = curtrack_id3.offset;
 860         gui_syncsplash(0, str(LANG_RESTARTING_PLAYBACK));
 861     }
 862
 863     /* Blast it - audio buffer will have to be setup again next time
 864        something plays */
 865     audio_get_buffer(true, &size);
 866
 867     /* Restart playback if audio was running previously */
 868     if (was_playing)
 869         audio_play(offset);
 870 }
 871
 872 /* --- Routines called from multiple threads --- */
 873 static void set_current_codec(int codec_idx)
 874 {
 875     current_codec = codec_idx;
 876     dsp_configure(DSP_SWITCH_CODEC, codec_idx);
 877 }
 878
 879 #ifdef PLAYBACK_VOICE
 880 static void swap_codec(void)
 881 {
 882     int my_codec;
 883
 884     /* Swap nothing if no swap buffers exist */
 885     if (dram_buf == NULL)
 886     {
 887         logf("swap: no swap buffers");
 888         return;
 889     }
 890
 891     my_codec = current_codec;
 892
 893     logf("swapping out codec: %d", my_codec);
 894
 895     /* Invert this when a codec thread enters and leaves */
 896     swap_codec_parity = !swap_codec_parity;
 897
 898     /* If this is true, an odd number of calls has occurred and there's
 899        no codec thread waiting to swap us out when it locks and runs. This
 900        occurs when playback is stopped or when just starting playback and
 901        the audio thread is loading a codec; parities should always be even
 902        on entry when a thread calls this during playback */
 903     if (swap_codec_parity)
 904     {
 905         /* Save our current IRAM and DRAM */
 906 #ifdef IRAM_STEAL
 907         if (voice_iram_stolen)
 908         {
 909             logf("swap: iram restore");
 910             voice_iram_stolen = false;
 911             /* Don't swap trashed data into buffer as the voice IRAM will
 912                already be swapped out - should _always_ be the case if
 913                voice_iram_stolen is true since the voice has been swapped
 914                in beforehand */
 915             if (my_codec == CODEC_IDX_VOICE)
 916             {
 917                 logf("voice iram already swapped");
 918                 goto skip_iram_swap;
 919             }
 920         }
 921 #endif
 922
 923         memswap128(iram_buf, CODEC_IRAM_ORIGIN, CODEC_IRAM_SIZE);
 924
 925 #ifdef IRAM_STEAL
 926     skip_iram_swap:
 927 #endif
 928
 929         memswap128(dram_buf, codecbuf, CODEC_SIZE);
 930         /* No cache invalidation needed; it will be done in codec_load_ram
 931            or we won't be here otherwise */
 932     }
 933
 934     /* Release my semaphore */
 935     semaphore_release(&sem_codecthread);
 936     logf("unlocked: %d", my_codec);
 937
 938     /* Wait for other codec */
 939     event_wait(&event_codecthread,
 940         (my_codec == CODEC_IDX_AUDIO) ? STATE_NONSIGNALED : STATE_SIGNALED);
 941
 942     /* Wait for other codec to unlock */
 943     logf("waiting for lock: %d", my_codec);
 944     semaphore_wait(&sem_codecthread);
 945
 946     /* Take control */
 947     set_current_codec(my_codec);
 948     event_set_state(&event_codecthread,
 949         (my_codec == CODEC_IDX_AUDIO) ? STATE_SIGNALED : STATE_NONSIGNALED);
 950
 951     /* Reload our IRAM and DRAM */
 952     memswap128(iram_buf, CODEC_IRAM_ORIGIN, CODEC_IRAM_SIZE);
 953     memswap128(dram_buf, codecbuf, CODEC_SIZE);
 954     invalidate_icache();
 955
 956     /* Flip parity again */
 957     swap_codec_parity = !swap_codec_parity;
 958
 959     logf("resuming codec: %d", my_codec);
 960 }
 961
 962 /* This function is meant to be used by the buffer stealing functions to
 963    ensure the codec is no longer active and so voice will be swapped-in
 964    before it is called */
 965 static void voice_stop(void)
 966 {
 967     /* Must have a voice codec loaded or we'll hang forever here */
 968     if (!voice_codec_loaded)
 969         return;
 970
 971     talk_force_shutup();
 972
 973     /* Loop until voice empties it's queue, stops and picks up on the new
 974        track; the voice thread must be stopped and waiting for messages
 975        outside the codec */
 976     while (voice_is_playing || !queue_empty(&voice_queue) ||
 977            ci_voice.new_track)
 978         yield();
 979
 980     if (!playing)
 981         pcmbuf_play_stop();
 982 } /* voice_stop */
 983
 984 /* Is voice still speaking */
 985 /* Unfortunately only reliable when music is not also playing. */
 986 static bool is_voice_speaking(void)
 987 {
 988     return is_voice_queued()
 989         || voice_is_playing
 990         || (!playing && pcm_is_playing());
 991 }
 992
 993 #endif /* PLAYBACK_VOICE */
 994
 995 /* Wait for voice to finish speaking. */
 996 /* Also only reliable when music is not also playing. */
 997 void voice_wait(void)
 998 {
 999 #ifdef PLAYBACK_VOICE
1000     while (is_voice_speaking())
1001         sleep(HZ/10);
1002 #endif
1003 }
1004
1005 static void set_filebuf_watermark(int seconds)
1006 {
1007     size_t bytes;
1008
1009     if (!filebuf)
1010         return;     /* Audio buffers not yet set up */
1011
1012     bytes = MAX(curtrack_id3.bitrate * seconds * (1000/8), conf_watermark);
1013     bytes = MIN(bytes, filebuflen / 2);
1014     conf_watermark = bytes;
1015 }
1016
1017 const char * get_codec_filename(int cod_spec)
1018 {
1019     const char *fname;
1020
1021 #ifdef HAVE_RECORDING
1022     /* Can choose decoder or encoder if one available */
1023     int type = cod_spec & CODEC_TYPE_MASK;
1024     int afmt = cod_spec & CODEC_AFMT_MASK;
1025
1026     if ((unsigned)afmt >= AFMT_NUM_CODECS)
1027         type = AFMT_UNKNOWN | (type & CODEC_TYPE_MASK);
1028
1029     fname = (type == CODEC_TYPE_ENCODER) ?
1030                 audio_formats[afmt].codec_enc_root_fn :
1031                 audio_formats[afmt].codec_root_fn;
1032
1033     logf("%s: %d - %s",
1034         (type == CODEC_TYPE_ENCODER) ? "Encoder" : "Decoder",
1035         afmt, fname ? fname : "<unknown>");
1036 #else /* !HAVE_RECORDING */
1037     /* Always decoder */
1038     if ((unsigned)cod_spec >= AFMT_NUM_CODECS)
1039         cod_spec = AFMT_UNKNOWN;
1040     fname = audio_formats[cod_spec].codec_root_fn;
1041     logf("Codec: %d - %s",  cod_spec, fname ? fname : "<unknown>");
1042 #endif /* HAVE_RECORDING */
1043
1044     return fname;
1045 } /* get_codec_filename */
1046
1047
1048 /* --- Voice thread --- */
1049
1050 #ifdef PLAYBACK_VOICE
1051
1052 static bool voice_pcmbuf_insert_callback(
1053         const void *ch1, const void *ch2, int count)
1054 {
1055     const char *src[2] = { ch1, ch2 };
1056
1057     while (count > 0)
1058     {
1059         int out_count = dsp_output_count(count);
1060         int inp_count;
1061         char *dest;
1062
1063         while ((dest = pcmbuf_request_voice_buffer(
1064                         &out_count, playing)) == NULL)
1065         {
1066             if (playing && audio_codec_loaded)
1067                 swap_codec();
1068             else
1069                 yield();
1070         }
1071
1072         /* Get the real input_size for output_size bytes, guarding
1073          * against resampling buffer overflows. */
1074         inp_count = dsp_input_count(out_count);
1075
1076         if (inp_count <= 0)
1077             return true;
1078
1079         /* Input size has grown, no error, just don't write more than length */
1080         if (inp_count > count)
1081             inp_count = count;
1082
1083         out_count = dsp_process(dest, src, inp_count);
1084
1085         if (out_count <= 0)
1086             return true;
1087
1088         if (playing)
1089         {
1090             pcmbuf_mix_voice(out_count);
1091             if ((pcmbuf_usage() < 10 || pcmbuf_mix_free() < 30) &&
1092                     audio_codec_loaded)
1093                 swap_codec();
1094         }
1095         else
1096             pcmbuf_write_complete(out_count);
1097
1098         count -= inp_count;
1099     }
1100
1101     return true;
1102 } /* voice_pcmbuf_insert_callback */
1103
1104 static void* voice_get_memory_callback(size_t *size)
1105 {
1106     /* Voice should have no use for this. If it did, we'd have to
1107        swap the malloc buffer as well. */
1108     *size = 0;
1109     return NULL;
1110 }
1111
1112 static void voice_set_elapsed_callback(unsigned int value)
1113 {
1114     (void)value;
1115 }
1116
1117 static void voice_set_offset_callback(size_t value)
1118 {
1119     (void)value;
1120 }
1121
1122 static void voice_configure_callback(int setting, intptr_t value)
1123 {
1124     if (!dsp_configure(setting, value))
1125     {
1126         logf("Illegal key:%d", setting);
1127     }
1128 }
1129
1130 static size_t voice_filebuf_callback(void *ptr, size_t size)
1131 {
1132     (void)ptr;
1133     (void)size;
1134
1135     return 0;
1136 }
1137
1138 /* Handle Q_VOICE_STOP and part of SYS_USB_CONNECTED */
1139 static bool voice_on_voice_stop(bool aborting, size_t *realsize)
1140 {
1141     if (aborting && !playing)
1142     {
1143         /* Aborting: Slight hack - flush PCM buffer if
1144            only being used for voice */
1145         pcmbuf_play_stop();
1146     }
1147
1148     if (voice_is_playing)
1149     {
1150         /* Clear the current buffer */
1151         voice_is_playing = false;
1152         voice_getmore = NULL;
1153         voice_remaining = 0;
1154         voicebuf = NULL;
1155
1156         /* Cancel any automatic boost if no more clips requested. */
1157         if (!playing || !voice_thread_start)
1158             sleep(0);
1159
1160         /* Force the codec to think it's changing tracks */
1161         ci_voice.new_track = 1;
1162
1163         *realsize = 0;
1164         return true; /* Yes, change tracks */
1165     }
1166
1167     return false;
1168 }
1169
1170 static void* voice_request_buffer_callback(size_t *realsize, size_t reqsize)
1171 {
1172     struct queue_event ev;
1173
1174     if (ci_voice.new_track)
1175     {
1176         *realsize = 0;
1177         return NULL;
1178     }
1179
1180     while (1)
1181     {
1182         if (voice_is_playing || playing)
1183         {
1184             queue_wait_w_tmo(&voice_queue, &ev, 0);
1185             if (!voice_is_playing && ev.id == SYS_TIMEOUT)
1186                 ev.id = Q_AUDIO_PLAY;
1187         }
1188         else
1189         {
1190             queue_wait(&voice_queue, &ev);
1191         }
1192
1193         switch (ev.id) {
1194             case Q_AUDIO_PLAY:
1195                 LOGFQUEUE("voice < Q_AUDIO_PLAY");
1196                 if (playing)
1197                 {
1198                     if (audio_codec_loaded)
1199                         swap_codec();
1200                     yield();
1201                 }
1202                 break;
1203
1204 #ifdef AUDIO_HAVE_RECORDING
1205             case Q_ENCODER_RECORD:
1206                 LOGFQUEUE("voice < Q_ENCODER_RECORD");
1207                 swap_codec();
1208                 break;
1209 #endif
1210
1211             case Q_VOICE_STOP:
1212                 LOGFQUEUE("voice < Q_VOICE_STOP");
1213                 if (voice_on_voice_stop(ev.data, realsize))
1214                     return NULL;
1215                 break;
1216
1217             case SYS_USB_CONNECTED:
1218             {
1219                 LOGFQUEUE("voice < SYS_USB_CONNECTED");
1220                 bool change_tracks = voice_on_voice_stop(ev.data, realsize);
1221                 /* Voice is obviously current so let us swap ourselves away if
1222                    playing so audio may stop itself - audio_codec_loaded can
1223                    only be true in this case if we're here even if the codec
1224                    is only about to load */
1225                 if (audio_codec_loaded)
1226                     swap_codec();
1227                 /* Playback should be finished by now - ack and wait */
1228                 usb_acknowledge(SYS_USB_CONNECTED_ACK);
1229                 usb_wait_for_disconnect(&voice_queue);
1230                 if (change_tracks)
1231                     return NULL;
1232                 break;
1233                 }
1234
1235             case Q_VOICE_PLAY:
1236                 LOGFQUEUE("voice < Q_VOICE_PLAY");
1237                 if (!voice_is_playing)
1238                 {
1239                     /* Set up new voice data */
1240                     struct voice_info *voice_data;
1241 #ifdef IRAM_STEAL
1242                     if (voice_iram_stolen)
1243                     {
1244                         /* Voice is the first to run again and is currently
1245                            loaded */
1246                         logf("voice: iram restore");
1247                         memcpy(CODEC_IRAM_ORIGIN, iram_buf, CODEC_IRAM_SIZE);
1248                         voice_iram_stolen = false;
1249                     }
1250 #endif
1251                     /* Must reset the buffer before any playback begins if
1252                        needed */
1253                     if (buffer_state == BUFFER_STATE_TRASHED)
1254                         audio_reset_buffer();
1255
1256                     voice_is_playing = true;
1257                     trigger_cpu_boost();
1258                     voice_data = (struct voice_info *)ev.data;
1259                     voice_remaining = voice_data->size;
1260                     voicebuf = voice_data->buf;
1261                     voice_getmore = voice_data->callback;
1262                 }
1263                 goto voice_play_clip; /* To exit both switch and while */
1264
1265             case SYS_TIMEOUT:
1266                 LOGFQUEUE_SYS_TIMEOUT("voice < SYS_TIMEOUT");
1267                 goto voice_play_clip;
1268
1269             default:
1270                 LOGFQUEUE("voice < default");
1271         }
1272     }
1273
1274 voice_play_clip:
1275
1276     if (voice_remaining == 0 || voicebuf == NULL)
1277     {
1278         if (voice_getmore)
1279             voice_getmore((unsigned char **)&voicebuf, &voice_remaining);
1280
1281         /* If this clip is done */
1282         if (voice_remaining == 0)
1283         {
1284             LOGFQUEUE("voice > voice Q_VOICE_STOP");
1285             queue_post(&voice_queue, Q_VOICE_STOP, 0);
1286             /* Force pcm playback. */
1287             if (!pcm_is_playing())
1288                 pcmbuf_play_start();
1289         }
1290     }
1291
1292     *realsize = MIN(voice_remaining, reqsize);
1293
1294     if (*realsize == 0)
1295         return NULL;
1296
1297     return voicebuf;
1298 } /* voice_request_buffer_callback */
1299
1300 static void voice_advance_buffer_callback(size_t amount)
1301 {
1302     amount = MIN(amount, voice_remaining);
1303     voicebuf += amount;
1304     voice_remaining -= amount;
1305 }
1306
1307 static void voice_advance_buffer_loc_callback(void *ptr)
1308 {
1309     size_t amount = (size_t)ptr - (size_t)voicebuf;
1310
1311     voice_advance_buffer_callback(amount);
1312 }
1313
1314 static off_t voice_mp3_get_filepos_callback(int newtime)
1315 {
1316     (void)newtime;
1317
1318     return 0;
1319 }
1320
1321 static void voice_do_nothing(void)
1322 {
1323     return;
1324 }
1325
1326 static bool voice_seek_buffer_callback(size_t newpos)
1327 {
1328     (void)newpos;
1329
1330     return false;
1331 }
1332
1333 static bool voice_request_next_track_callback(void)
1334 {
1335     ci_voice.new_track = 0;
1336     return true;
1337 }
1338
1339 static void voice_thread(void)
1340 {
1341     logf("Loading voice codec");
1342     voice_codec_loaded = true;
1343     semaphore_wait(&sem_codecthread);
1344     event_set_state(&event_codecthread, false);
1345     set_current_codec(CODEC_IDX_VOICE);
1346     dsp_configure(DSP_RESET, 0);
1347     voice_remaining = 0;
1348     voice_getmore = NULL;
1349
1350     /* FIXME: If we being starting the voice thread without reboot, the
1351        voice_queue could be full of old stuff and we must flush it. */
1352     codec_load_file(get_codec_filename(AFMT_MPA_L3), &ci_voice);
1353
1354     logf("Voice codec finished");
1355     voice_codec_loaded = false;
1356     voice_thread_p = NULL;
1357     semaphore_release(&sem_codecthread);
1358 } /* voice_thread */
1359
1360 #endif /* PLAYBACK_VOICE */
1361
1362 /* --- Codec thread --- */
1363 static bool codec_pcmbuf_insert_callback(
1364         const void *ch1, const void *ch2, int count)
1365 {
1366     const char *src[2] = { ch1, ch2 };
1367
1368     while (count > 0)
1369     {
1370         int out_count = dsp_output_count(count);
1371         int inp_count;
1372         char *dest;
1373
1374         /* Prevent audio from a previous track from playing */
1375         if (ci.new_track || ci.stop_codec)
1376             return true;
1377
1378         while ((dest = pcmbuf_request_buffer(&out_count)) == NULL)
1379         {
1380             sleep(1);
1381             if (ci.seek_time || ci.new_track || ci.stop_codec)
1382                 return true;
1383         }
1384
1385         /* Get the real input_size for output_size bytes, guarding
1386          * against resampling buffer overflows. */
1387         inp_count = dsp_input_count(out_count);
1388
1389         if (inp_count <= 0)
1390             return true;
1391
1392         /* Input size has grown, no error, just don't write more than length */
1393         if (inp_count > count)
1394             inp_count = count;
1395
1396         out_count = dsp_process(dest, src, inp_count);
1397
1398         if (out_count <= 0)
1399             return true;
1400
1401         pcmbuf_write_complete(out_count);
1402
1403 #ifdef PLAYBACK_VOICE
1404         if ((voice_is_playing || voice_thread_start)
1405             && pcm_is_playing() && voice_codec_loaded &&
1406             pcmbuf_usage() > 30 && pcmbuf_mix_free() > 80)
1407         {
1408             voice_thread_start = false;
1409             swap_codec();
1410         }
1411 #endif
1412
1413         count -= inp_count;
1414     }
1415
1416     return true;
1417 } /* codec_pcmbuf_insert_callback */
1418
1419 static void* codec_get_memory_callback(size_t *size)
1420 {
1421     *size = MALLOC_BUFSIZE;
1422     return malloc_buf;
1423 }
1424
1425 static void codec_pcmbuf_position_callback(size_t size) ICODE_ATTR;
1426 static void codec_pcmbuf_position_callback(size_t size)
1427 {
1428     /* This is called from an ISR, so be quick */
1429     unsigned int time = size * 1000 / 4 / NATIVE_FREQUENCY +
1430         prev_ti->id3.elapsed;
1431
1432     if (time >= prev_ti->id3.length)
1433     {
1434         pcmbuf_set_position_callback(NULL);
1435         prev_ti->id3.elapsed = prev_ti->id3.length;
1436     }
1437     else
1438         prev_ti->id3.elapsed = time;
1439 }
1440
1441 static void codec_set_elapsed_callback(unsigned int value)
1442 {
1443     unsigned int latency;
1444     if (ci.seek_time)
1445         return;
1446
1447 #ifdef AB_REPEAT_ENABLE
1448     ab_position_report(value);
1449 #endif
1450
1451     latency = pcmbuf_get_latency();
1452     if (value < latency)
1453         curtrack_id3.elapsed = 0;
1454     else if (value - latency > curtrack_id3.elapsed ||
1455             value - latency < curtrack_id3.elapsed - 2)
1456     {
1457         curtrack_id3.elapsed = value - latency;
1458     }
1459 }
1460
1461 static void codec_set_offset_callback(size_t value)
1462 {
1463     unsigned int latency;
1464
1465     if (ci.seek_time)
1466         return;
1467
1468     latency = pcmbuf_get_latency() * curtrack_id3.bitrate / 8;
1469     if (value < latency)
1470         curtrack_id3.offset = 0;
1471     else
1472         curtrack_id3.offset = value - latency;
1473 }
1474
1475 static void codec_advance_buffer_counters(size_t amount)
1476 {
1477     bufadvance(CUR_TI->audio_hid, amount);
1478
1479     /* Start buffer filling as necessary. */
1480     if (!pcmbuf_is_lowdata() && !filling)
1481     {
1482         if (FILEBUFUSED < conf_watermark && playing && !playlist_end)
1483         {
1484             LOGFQUEUE("codec > audio Q_AUDIO_FILL_BUFFER");
1485             queue_post(&audio_queue, Q_AUDIO_FILL_BUFFER, 0);
1486         }
1487     }
1488 }
1489
1490 /* copy up-to size bytes into ptr and return the actual size copied */
1491 static size_t codec_filebuf_callback(void *ptr, size_t size)
1492 {
1493     size_t copy_n;
1494
1495     if (ci.stop_codec || !playing)
1496         return 0;
1497
1498     copy_n = bufread(CUR_TI->audio_hid, size, ptr);
1499
1500     /* Nothing requested OR nothing left */
1501     if (copy_n == 0)
1502         return 0;
1503
1504     /* Let the disk buffer catch fill until enough data is available */
1505     while (copy_n == -2)
1506     {
1507         if (!filling)
1508         {
1509             LOGFQUEUE("codec > audio Q_AUDIO_FILL_BUFFER");
1510             queue_post(&audio_queue, Q_AUDIO_FILL_BUFFER, 0);
1511         }
1512
1513         sleep(1);
1514         if (ci.stop_codec || ci.new_track)
1515             return 0;
1516     }
1517
1518     /* Update read and other position pointers */
1519     codec_advance_buffer_counters(copy_n);
1520
1521     /* Return the actual amount of data copied to the buffer */
1522     return copy_n;
1523 } /* codec_filebuf_callback */
1524
1525 static void* codec_request_buffer_callback(size_t *realsize, size_t reqsize)
1526 {
1527     size_t short_n, copy_n, buf_rem;
1528     char *ret;
1529
1530     if (!playing)
1531     {
1532         *realsize = 0;
1533         return NULL;
1534     }
1535
1536     copy_n = bufgetdata(CUR_TI->audio_hid, reqsize, &ret);
1537     if (copy_n == 0)
1538     {
1539         *realsize = 0;
1540         return NULL;
1541     }
1542
1543     while (copy_n == -2)
1544     {
1545         if (!filling)
1546         {
1547             LOGFQUEUE("codec > audio Q_AUDIO_FILL_BUFFER");
1548             queue_post(&audio_queue, Q_AUDIO_FILL_BUFFER, 0);
1549         }
1550
1551         sleep(1);
1552         if (ci.stop_codec || ci.new_track)
1553         {
1554             *realsize = 0;
1555             return NULL;
1556         }
1557     }
1558
1559     *realsize = copy_n;
1560
1561     return ret;
1562 } /* codec_request_buffer_callback */
1563
1564 static int get_codec_base_type(int type)
1565 {
1566     switch (type) {
1567         case AFMT_MPA_L1:
1568         case AFMT_MPA_L2:
1569         case AFMT_MPA_L3:
1570             return AFMT_MPA_L3;
1571     }
1572
1573     return type;
1574 }
1575
1576 static void codec_advance_buffer_callback(size_t amount)
1577 {
1578     if (amount > CUR_TI->available + CUR_TI->filerem)
1579         amount = CUR_TI->available + CUR_TI->filerem;
1580
1581     while (amount > CUR_TI->available && filling)
1582         sleep(1);
1583
1584     if (amount > CUR_TI->available)
1585     {
1586         intptr_t result = Q_CODEC_REQUEST_FAILED;
1587
1588         if (!ci.stop_codec)
1589         {
1590             LOGFQUEUE("codec >| audio Q_AUDIO_REBUFFER_SEEK");
1591             result = queue_send(&audio_queue, Q_AUDIO_REBUFFER_SEEK,
1592                                 ci.curpos + amount);
1593         }
1594
1595         switch (result)
1596         {
1597             case Q_CODEC_REQUEST_FAILED:
1598                 LOGFQUEUE("codec |< Q_CODEC_REQUEST_FAILED");
1599                 ci.stop_codec = true;
1600                 return;
1601
1602             case Q_CODEC_REQUEST_COMPLETE:
1603                 LOGFQUEUE("codec |< Q_CODEC_REQUEST_COMPLETE");
1604                 return;
1605
1606             default:
1607                 LOGFQUEUE("codec |< default");
1608                 ci.stop_codec = true;
1609                 return;
1610         }
1611     }
1612
1613     codec_advance_buffer_counters(amount);
1614
1615     codec_set_offset_callback(ci.curpos);
1616 }
1617
1618 static void codec_advance_buffer_loc_callback(void *ptr)
1619 {
1620     size_t amount = (size_t)ptr - (size_t)&filebuf[buf_ridx];
1621
1622     codec_advance_buffer_callback(amount);
1623 }
1624
1625 /* Copied from mpeg.c. Should be moved somewhere else. */
1626 static int codec_get_file_pos(void)
1627 {
1628     int pos = -1;
1629     struct mp3entry *id3 = audio_current_track();
1630
1631     if (id3->vbr)
1632     {
1633         if (id3->has_toc)
1634         {
1635             /* Use the TOC to find the new position */
1636             unsigned int percent, remainder;
1637             int curtoc, nexttoc, plen;
1638
1639             percent = (id3->elapsed*100)/id3->length;
1640             if (percent > 99)
1641                 percent = 99;
1642
1643             curtoc = id3->toc[percent];
1644
1645             if (percent < 99)
1646                 nexttoc = id3->toc[percent+1];
1647             else
1648                 nexttoc = 256;
1649
1650             pos = (id3->filesize/256)*curtoc;
1651
1652             /* Use the remainder to get a more accurate position */
1653             remainder   = (id3->elapsed*100)%id3->length;
1654             remainder   = (remainder*100)/id3->length;
1655             plen        = (nexttoc - curtoc)*(id3->filesize/256);
1656             pos        += (plen/100)*remainder;
1657         }
1658         else
1659         {
1660             /* No TOC exists, estimate the new position */
1661             pos = (id3->filesize / (id3->length / 1000)) *
1662                 (id3->elapsed / 1000);
1663         }
1664     }
1665     else if (id3->bitrate)
1666         pos = id3->elapsed * (id3->bitrate / 8);
1667     else
1668         return -1;
1669
1670     pos += id3->first_frame_offset;
1671
1672     /* Don't seek right to the end of the file so that we can
1673        transition properly to the next song */
1674     if (pos >= (int)(id3->filesize - id3->id3v1len))
1675         pos = id3->filesize - id3->id3v1len - 1;
1676
1677     return pos;
1678 }
1679
1680 static off_t codec_mp3_get_filepos_callback(int newtime)
1681 {
1682     off_t newpos;
1683
1684     curtrack_id3.elapsed = newtime;
1685     newpos = codec_get_file_pos();
1686
1687     return newpos;
1688 }
1689
1690 static void codec_seek_complete_callback(void)
1691 {
1692     logf("seek_complete");
1693     if (pcm_is_paused())
1694     {
1695         /* If this is not a seamless seek, clear the buffer */
1696         pcmbuf_play_stop();
1697         dsp_configure(DSP_FLUSH, 0);
1698
1699         /* If playback was not 'deliberately' paused, unpause now */
1700         if (!paused)
1701             pcmbuf_pause(false);
1702     }
1703     ci.seek_time = 0;
1704 }
1705
1706 static bool codec_seek_buffer_callback(size_t newpos)
1707 {
1708     int difference;
1709
1710     logf("codec_seek_buffer_callback");
1711
1712     if (newpos >= CUR_TI->filesize)
1713         newpos = CUR_TI->filesize - 1;
1714
1715     difference = newpos - ci.curpos;
1716     if (difference >= 0)
1717     {
1718         /* Seeking forward */
1719         logf("seek: +%d", difference);
1720         codec_advance_buffer_callback(difference);
1721         return true;
1722     }
1723
1724     /* Seeking backward */
1725     difference = -difference;
1726     if (ci.curpos - difference < 0)
1727         difference = ci.curpos;
1728
1729     /* We need to reload the song. */
1730     if (newpos < CUR_TI->start_pos)
1731     {
1732         intptr_t result = Q_CODEC_REQUEST_FAILED;
1733
1734         if (!ci.stop_codec)
1735         {
1736             LOGFQUEUE("codec >| audio Q_AUDIO_REBUFFER_SEEK");
1737             result = queue_send(&audio_queue, Q_AUDIO_REBUFFER_SEEK,
1738                                 newpos);
1739         }
1740
1741         switch (result)
1742         {
1743             case Q_CODEC_REQUEST_COMPLETE:
1744                 LOGFQUEUE("codec |< Q_CODEC_REQUEST_COMPLETE");
1745                 return true;
1746
1747             case Q_CODEC_REQUEST_FAILED:
1748                 LOGFQUEUE("codec |< Q_CODEC_REQUEST_FAILED");
1749                 ci.stop_codec = true;
1750                 return false;
1751
1752             default:
1753                 LOGFQUEUE("codec |< default");
1754                 return false;
1755         }
1756     }
1757
1758     /* Seeking inside buffer space. */
1759     logf("seek: -%d", difference);
1760     CUR_TI->available += difference;
1761     buf_ridx = RINGBUF_SUB(buf_ridx, (unsigned)difference);
1762     ci.curpos -= difference;
1763
1764     return true;
1765 }
1766
1767 static void codec_configure_callback(int setting, intptr_t value)
1768 {
1769     switch (setting) {
1770     case CODEC_SET_FILEBUF_WATERMARK:
1771         conf_watermark = value;
1772         set_filebuf_watermark(buffer_margin);
1773         break;
1774
1775     case CODEC_SET_FILEBUF_CHUNKSIZE:
1776         conf_filechunk = value;
1777         break;
1778
1779     case CODEC_SET_FILEBUF_PRESEEK:
1780         conf_preseek = value;
1781         break;
1782
1783     default:
1784         if (!dsp_configure(setting, value)) { logf("Illegal key:%d", setting); }
1785     }
1786 }
1787
1788 static void codec_track_changed(void)
1789 {
1790     automatic_skip = false;
1791     LOGFQUEUE("codec > audio Q_AUDIO_TRACK_CHANGED");
1792     queue_post(&audio_queue, Q_AUDIO_TRACK_CHANGED, 0);
1793 }
1794
1795 static void codec_pcmbuf_track_changed_callback(void)
1796 {
1797     pcmbuf_set_position_callback(NULL);
1798     codec_track_changed();
1799 }
1800
1801 static void codec_discard_codec_callback(void)
1802 {
1803     if (CUR_TI->has_codec)
1804     {
1805         CUR_TI->has_codec = false;
1806         if (CUR_TI->codec_hid > 0)
1807         {
1808             bufclose(CUR_TI->codec_hid);
1809             CUR_TI->codec_hid = 0;
1810         }
1811     }
1812
1813 #if 0
1814     /* Check if a buffer desync has happened, log it and stop playback. */
1815     if (buf_ridx != CUR_TI->buf_idx)
1816     {
1817         int offset = CUR_TI->buf_idx - buf_ridx;
1818         size_t new_used = FILEBUFUSED - offset;
1819
1820         logf("Buf off :%d=%d-%d", offset, CUR_TI->buf_idx, buf_ridx);
1821         logf("Used off:%d",FILEBUFUSED - new_used);
1822
1823         /* This is a fatal internal error and it's not safe to
1824          * continue playback. */
1825         ci.stop_codec = true;
1826         queue_post(&audio_queue, Q_AUDIO_STOP, 0);
1827     }
1828 #endif
1829 }
1830
1831 static inline void codec_gapless_track_change(void) {
1832     /* callback keeps the progress bar moving while the pcmbuf empties */
1833     pcmbuf_set_position_callback(codec_pcmbuf_position_callback);
1834     /* set the pcmbuf callback for when the track really changes */
1835     pcmbuf_set_event_handler(codec_pcmbuf_track_changed_callback);
1836 }
1837
1838 static inline void codec_crossfade_track_change(void) {
1839     /* Initiate automatic crossfade mode */
1840     pcmbuf_crossfade_init(false);
1841     /* Notify the wps that the track change starts now */
1842     codec_track_changed();
1843 }
1844
1845 static void codec_track_skip_done(bool was_manual)
1846 {
1847     int crossfade_mode = global_settings.crossfade;
1848
1849     /* Manual track change (always crossfade or flush audio). */
1850     if (was_manual)
1851     {
1852         pcmbuf_crossfade_init(true);
1853         LOGFQUEUE("codec > audio Q_AUDIO_TRACK_CHANGED");
1854         queue_post(&audio_queue, Q_AUDIO_TRACK_CHANGED, 0);
1855     }
1856     /* Automatic track change w/crossfade, if not in "Track Skip Only" mode. */
1857     else if (pcmbuf_is_crossfade_enabled() && !pcmbuf_is_crossfade_active()
1858              && crossfade_mode != CROSSFADE_ENABLE_TRACKSKIP)
1859     {
1860         if (crossfade_mode == CROSSFADE_ENABLE_SHUFFLE_AND_TRACKSKIP)
1861         {
1862             if (global_settings.playlist_shuffle)
1863                 /* shuffle mode is on, so crossfade: */
1864                 codec_crossfade_track_change();
1865             else
1866                 /* shuffle mode is off, so do a gapless track change */
1867                 codec_gapless_track_change();
1868         }
1869         else
1870             /* normal crossfade:  */
1871             codec_crossfade_track_change();
1872     }
1873     else
1874         /* normal gapless playback. */
1875         codec_gapless_track_change();
1876 }
1877
1878 static bool codec_load_next_track(void)
1879 {
1880     intptr_t result = Q_CODEC_REQUEST_FAILED;
1881
1882     prev_track_elapsed = curtrack_id3.elapsed;
1883
1884     if (ci.seek_time)
1885         codec_seek_complete_callback();
1886
1887 #ifdef AB_REPEAT_ENABLE
1888     ab_end_of_track_report();
1889 #endif
1890
1891     logf("Request new track");
1892
1893     if (ci.new_track == 0)
1894     {
1895         ci.new_track++;
1896         automatic_skip = true;
1897     }
1898
1899     if (!ci.stop_codec)
1900     {
1901         trigger_cpu_boost();
1902         LOGFQUEUE("codec >| audio Q_AUDIO_CHECK_NEW_TRACK");
1903         result = queue_send(&audio_queue, Q_AUDIO_CHECK_NEW_TRACK, 0);
1904     }
1905
1906     switch (result)
1907     {
1908         case Q_CODEC_REQUEST_COMPLETE:
1909             LOGFQUEUE("codec |< Q_CODEC_REQUEST_COMPLETE");
1910             codec_track_skip_done(!automatic_skip);
1911             return true;
1912
1913         case Q_CODEC_REQUEST_FAILED:
1914             LOGFQUEUE("codec |< Q_CODEC_REQUEST_FAILED");
1915             ci.new_track = 0;
1916             ci.stop_codec = true;
1917             return false;
1918
1919         default:
1920             LOGFQUEUE("codec |< default");
1921             ci.stop_codec = true;
1922             return false;
1923     }
1924 }
1925
1926 static bool codec_request_next_track_callback(void)
1927 {
1928     int prev_codectype;
1929
1930     if (ci.stop_codec || !playing)
1931         return false;
1932
1933     prev_codectype = get_codec_base_type(curtrack_id3.codectype);
1934
1935     if (!codec_load_next_track())
1936         return false;
1937
1938     /* Check if the next codec is the same file. */
1939     if (prev_codectype == get_codec_base_type(curtrack_id3.codectype))
1940     {
1941         logf("New track loaded");
1942         codec_discard_codec_callback();
1943         return true;
1944     }
1945     else
1946     {
1947         logf("New codec:%d/%d", curtrack_id3.codectype, prev_codectype);
1948         return false;
1949     }
1950 }
1951
1952 static void codec_thread(void)
1953 {
1954     struct queue_event ev;
1955     int status;
1956     size_t wrap;
1957
1958     while (1) {
1959         status = 0;
1960         queue_wait(&codec_queue, &ev);
1961
1962         switch (ev.id) {
1963             case Q_CODEC_LOAD_DISK:
1964                 LOGFQUEUE("codec < Q_CODEC_LOAD_DISK");
1965                 audio_codec_loaded = true;
1966 #ifdef PLAYBACK_VOICE
1967                 /* Don't sent messages to voice codec if it's already swapped
1968                    out or it will never get this */
1969                 if (voice_codec_loaded && current_codec == CODEC_IDX_VOICE)
1970                 {
1971                     LOGFQUEUE("codec > voice Q_AUDIO_PLAY");
1972                     queue_post(&voice_queue, Q_AUDIO_PLAY, 0);
1973                 }
1974                 semaphore_wait(&sem_codecthread);
1975                 event_set_state(&event_codecthread, true);
1976 #endif
1977                 set_current_codec(CODEC_IDX_AUDIO);
1978                 ci.stop_codec = false;
1979                 status = codec_load_file((const char *)ev.data, &ci);
1980 #ifdef PLAYBACK_VOICE
1981                 semaphore_release(&sem_codecthread);
1982 #endif
1983                 break;
1984
1985             case Q_CODEC_LOAD:
1986                 LOGFQUEUE("codec < Q_CODEC_LOAD");
1987                 if (!CUR_TI->has_codec) {
1988                     logf("Codec slot is empty!");
1989                     /* Wait for the pcm buffer to go empty */
1990                     while (pcm_is_playing())
1991                         yield();
1992                     /* This must be set to prevent an infinite loop */
1993                     ci.stop_codec = true;
1994                     LOGFQUEUE("codec > codec Q_AUDIO_PLAY");
1995                     queue_post(&codec_queue, Q_AUDIO_PLAY, 0);
1996                     break;
1997                 }
1998
1999                 audio_codec_loaded = true;
2000 #ifdef PLAYBACK_VOICE
2001                 if (voice_codec_loaded && current_codec == CODEC_IDX_VOICE)
2002                 {
2003                     LOGFQUEUE("codec > voice Q_AUDIO_PLAY");
2004                     queue_post(&voice_queue, Q_AUDIO_PLAY, 0);
2005                 }
2006                 semaphore_wait(&sem_codecthread);
2007                 event_set_state(&event_codecthread, true);
2008 #endif
2009                 set_current_codec(CODEC_IDX_AUDIO);
2010                 ci.stop_codec = false;
2011                 wrap = (size_t)&filebuf[filebuflen] - (size_t)CUR_TI->codecbuf;
2012                 status = codec_load_ram(CUR_TI->codecbuf, CUR_TI->codecsize,
2013                         &filebuf[0], wrap, &ci);
2014 #ifdef PLAYBACK_VOICE
2015                 semaphore_release(&sem_codecthread);
2016 #endif
2017                 break;
2018
2019 #ifdef AUDIO_HAVE_RECORDING
2020             case Q_ENCODER_LOAD_DISK:
2021                 LOGFQUEUE("codec < Q_ENCODER_LOAD_DISK");
2022                 audio_codec_loaded = false; /* Not audio codec! */
2023 #ifdef PLAYBACK_VOICE
2024                 if (voice_codec_loaded && current_codec == CODEC_IDX_VOICE)
2025                 {
2026                     LOGFQUEUE("codec > voice Q_ENCODER_RECORD");
2027                     queue_post(&voice_queue, Q_ENCODER_RECORD, 0);
2028                 }
2029                 semaphore_wait(&sem_codecthread);
2030                 event_set_state(&event_codecthread, true);
2031 #endif
2032                 logf("loading encoder");
2033                 set_current_codec(CODEC_IDX_AUDIO);
2034                 ci.stop_encoder = false;
2035                 status = codec_load_file((const char *)ev.data, &ci);
2036 #ifdef PLAYBACK_VOICE
2037                 semaphore_release(&sem_codecthread);
2038 #endif
2039                 logf("encoder stopped");
2040                 break;
2041 #endif /* AUDIO_HAVE_RECORDING */
2042
2043 #ifndef SIMULATOR
2044             case SYS_USB_CONNECTED:
2045                 LOGFQUEUE("codec < SYS_USB_CONNECTED");
2046                 queue_clear(&codec_queue);
2047                 usb_acknowledge(SYS_USB_CONNECTED_ACK);
2048                 usb_wait_for_disconnect(&codec_queue);
2049                 break;
2050 #endif
2051
2052             default:
2053                 LOGFQUEUE("codec < default");
2054         }
2055
2056         if (audio_codec_loaded)
2057         {
2058             if (ci.stop_codec)
2059             {
2060                 status = CODEC_OK;
2061                 if (!playing)
2062                     pcmbuf_play_stop();
2063
2064             }
2065             audio_codec_loaded = false;
2066         }
2067
2068         switch (ev.id) {
2069             case Q_CODEC_LOAD_DISK:
2070             case Q_CODEC_LOAD:
2071                 LOGFQUEUE("codec < Q_CODEC_LOAD");
2072                 if (playing)
2073                 {
2074                     if (ci.new_track || status != CODEC_OK)
2075                     {
2076                         if (!ci.new_track)
2077                         {
2078                             logf("Codec failure");
2079                             gui_syncsplash(HZ*2, "Codec failure");
2080                         }
2081
2082                         if (!codec_load_next_track())
2083                         {
2084                             LOGFQUEUE("codec > audio Q_AUDIO_STOP");
2085                             /* End of playlist */
2086                             queue_post(&audio_queue, Q_AUDIO_STOP, 0);
2087                             break;
2088                         }
2089                     }
2090                     else
2091                     {
2092                         logf("Codec finished");
2093                         if (ci.stop_codec)
2094                         {
2095                             /* Wait for the audio to stop playing before
2096                              * triggering the WPS exit */
2097                             while(pcm_is_playing())
2098                             {
2099                                 curtrack_id3.elapsed =
2100                                     curtrack_id3.length - pcmbuf_get_latency();
2101                                 sleep(1);
2102                             }
2103                             LOGFQUEUE("codec > audio Q_AUDIO_STOP");
2104                             /* End of playlist */
2105                             queue_post(&audio_queue, Q_AUDIO_STOP, 0);
2106                             break;
2107                         }
2108                     }
2109
2110                     if (CUR_TI->has_codec)
2111                     {
2112                         LOGFQUEUE("codec > codec Q_CODEC_LOAD");
2113                         queue_post(&codec_queue, Q_CODEC_LOAD, 0);
2114                     }
2115                     else
2116                     {
2117                         const char *codec_fn =
2118                             get_codec_filename(curtrack_id3.codectype);
2119                         LOGFQUEUE("codec > codec Q_CODEC_LOAD_DISK");
2120                         queue_post(&codec_queue, Q_CODEC_LOAD_DISK,
2121                             (intptr_t)codec_fn);
2122                     }
2123                 }
2124                 break;
2125
2126 #ifdef AUDIO_HAVE_RECORDING
2127             case Q_ENCODER_LOAD_DISK:
2128                 LOGFQUEUE("codec < Q_ENCODER_LOAD_DISK");
2129
2130                 if (status == CODEC_OK)
2131                     break;
2132
2133                 logf("Encoder failure");
2134                 gui_syncsplash(HZ*2, "Encoder failure");
2135
2136                 if (ci.enc_codec_loaded < 0)
2137                     break;
2138
2139                 logf("Encoder failed to load");
2140                 ci.enc_codec_loaded = -1;
2141                 break;
2142 #endif /* AUDIO_HAVE_RECORDING */
2143
2144             default:
2145                 LOGFQUEUE("codec < default");
2146
2147         } /* end switch */
2148     }
2149 }
2150
2151
2152 /* --- Audio thread --- */
2153
2154 static bool audio_filebuf_is_lowdata(void)
2155 {
2156     return FILEBUFUSED < AUDIO_FILEBUF_CRITICAL;
2157 }
2158
2159 static bool audio_have_tracks(void)
2160 {
2161     return track_ridx != track_widx || CUR_TI->filesize;
2162 }
2163
2164 static bool audio_have_free_tracks(void)
2165 {
2166     if (track_widx < track_ridx)
2167         return track_widx + 1 < track_ridx;
2168     else if (track_ridx == 0)
2169         return track_widx < MAX_TRACK - 1;
2170
2171     return true;
2172 }
2173
2174 int audio_track_count(void)
2175 {
2176     if (audio_have_tracks())
2177     {
2178         int relative_track_widx = track_widx;
2179
2180         if (track_ridx > track_widx)
2181             relative_track_widx += MAX_TRACK;
2182
2183         return relative_track_widx - track_ridx + 1;
2184     }
2185
2186     return 0;
2187 }
2188
2189 long audio_filebufused(void)
2190 {
2191     return (long) FILEBUFUSED;
2192 }
2193
2194 /* Count the data BETWEEN the selected tracks */
2195 static size_t audio_buffer_count_tracks(int from_track, int to_track)
2196 {
2197     size_t amount = 0;
2198     bool need_wrap = to_track < from_track;
2199
2200     while (1)
2201     {
2202         if (++from_track >= MAX_TRACK)
2203         {
2204             from_track -= MAX_TRACK;
2205             need_wrap = false;
2206         }
2207
2208         if (from_track >= to_track && !need_wrap)
2209             break;
2210
2211         amount += tracks[from_track].codecsize + tracks[from_track].filesize;
2212     }
2213     return amount;
2214 }
2215
2216 static bool audio_buffer_wind_forward(int new_track_ridx, int old_track_ridx)
2217 {
2218     size_t amount;
2219
2220     /* Start with the remainder of the previously playing track */
2221     amount = tracks[old_track_ridx].filesize - ci.curpos;
2222     /* Then collect all data from tracks in between them */
2223     amount += audio_buffer_count_tracks(old_track_ridx, new_track_ridx);
2224     logf("bwf:%ldB", (long) amount);
2225
2226     if (amount > FILEBUFUSED)
2227         return false;
2228
2229     /* Wind the buffer to the beginning of the target track or its codec */
2230     buf_ridx = RINGBUF_ADD(buf_ridx, amount);
2231
2232     return true;
2233 }
2234
2235 static bool audio_buffer_wind_backward(int new_track_ridx, int old_track_ridx)
2236 {
2237     /* Available buffer data */
2238     size_t buf_back;
2239     /* Start with the previously playing track's data and our data */
2240     size_t amount;
2241
2242     amount = ci.curpos;
2243     buf_back = RINGBUF_SUB(buf_ridx, buf_widx);
2244
2245     /* If we're not just resetting the current track */
2246     if (new_track_ridx != old_track_ridx)
2247     {
2248         /* Need to wind to before the old track's codec and our filesize */
2249         amount += tracks[old_track_ridx].codecsize;
2250         amount += tracks[new_track_ridx].filesize;
2251
2252         /* Rewind the old track to its beginning */
2253         tracks[old_track_ridx].available =
2254             tracks[old_track_ridx].filesize - tracks[old_track_ridx].filerem;
2255     }
2256
2257     /* If the codec was ever buffered */
2258     if (tracks[new_track_ridx].codecsize)
2259     {
2260         /* Add the codec to the needed size */
2261         amount += tracks[new_track_ridx].codecsize;
2262         tracks[new_track_ridx].has_codec = true;
2263     }
2264
2265     /* Then collect all data from tracks between new and old */
2266     amount += audio_buffer_count_tracks(new_track_ridx, old_track_ridx);
2267
2268     /* Do we have space to make this skip? */
2269     if (amount > buf_back)
2270         return false;
2271
2272     logf("bwb:%ldB",amount);
2273
2274     /* Rewind the buffer to the beginning of the target track or its codec */
2275     buf_ridx = RINGBUF_SUB(buf_ridx, amount);
2276
2277     /* Reset to the beginning of the new track */
2278     tracks[new_track_ridx].available = tracks[new_track_ridx].filesize;
2279
2280     return true;
2281 }
2282
2283 static void audio_update_trackinfo(void)
2284 {
2285     ci.filesize = CUR_TI->filesize;
2286     curtrack_id3.elapsed = 0;
2287     curtrack_id3.offset = 0;
2288     ci.id3 = &curtrack_id3;
2289     ci.curpos = 0;
2290     ci.taginfo_ready = &CUR_TI->taginfo_ready;
2291 }
2292
2293 /* Yield to codecs for as long as possible if they are in need of data
2294  * return true if the caller should break to let the audio thread process
2295  * new events */
2296 static bool audio_yield_codecs(void)
2297 {
2298     yield();
2299
2300     if (!queue_empty(&audio_queue))
2301         return true;
2302
2303     while ((pcmbuf_is_crossfade_active() || pcmbuf_is_lowdata())
2304             && !ci.stop_codec && playing && !audio_filebuf_is_lowdata())
2305     {
2306         if (filling)
2307             yield();
2308         else
2309             sleep(2);
2310
2311         if (!queue_empty(&audio_queue))
2312             return true;
2313     }
2314
2315     return false;
2316 }
2317
2318 static void audio_clear_track_entries(bool clear_unbuffered)
2319 {
2320     int cur_idx = track_widx;
2321     int last_idx = -1;
2322
2323     logf("Clearing tracks:%d/%d, %d", track_ridx, track_widx, clear_unbuffered);
2324
2325     /* Loop over all tracks from write-to-read */
2326     while (1)
2327     {
2328         cur_idx++;
2329         cur_idx &= MAX_TRACK_MASK;
2330
2331         if (cur_idx == track_ridx)
2332             break;
2333
2334         /* If the track is buffered, conditionally clear/notify,
2335          * otherwise clear the track if that option is selected */
2336         if (tracks[cur_idx].event_sent)
2337         {
2338             if (last_idx >= 0)
2339             {
2340                 /* If there is an unbuffer callback, call it, otherwise,
2341                  * just clear the track */
2342                 if (track_unbuffer_callback)
2343                     track_unbuffer_callback(&tracks[last_idx].id3, false);
2344
2345                 memset(&tracks[last_idx], 0, sizeof(struct track_info));
2346             }
2347             last_idx = cur_idx;
2348         }
2349         else if (clear_unbuffered)
2350             memset(&tracks[cur_idx], 0, sizeof(struct track_info));
2351     }
2352
2353     /* We clear the previous instance of a buffered track throughout
2354      * the above loop to facilitate 'last' detection.  Clear/notify
2355      * the last track here */
2356     if (last_idx >= 0)
2357     {
2358         if (track_unbuffer_callback)
2359             track_unbuffer_callback(&tracks[last_idx].id3, true);
2360         memset(&tracks[last_idx], 0, sizeof(struct track_info));
2361     }
2362 }
2363
2364 /* FIXME: This code should be made more generic and move to metadata.c */
2365 static void audio_strip_tags(void)
2366 {
2367     int i;
2368     static const unsigned char tag[] = "TAG";
2369     static const unsigned char apetag[] = "APETAGEX";
2370     size_t tag_idx;
2371     size_t cur_idx;
2372     size_t len, version;
2373
2374     tag_idx = RINGBUF_SUB(buf_widx, 128);
2375
2376     if (FILEBUFUSED > 128 && tag_idx > buf_ridx)
2377     {
2378         cur_idx = tag_idx;
2379         for(i = 0;i < 3;i++)
2380         {
2381             if(filebuf[cur_idx] != tag[i])
2382                 goto strip_ape_tag;
2383
2384             cur_idx = RINGBUF_ADD(cur_idx, 1);
2385         }
2386
2387         /* Skip id3v1 tag */
2388         logf("Skipping ID3v1 tag");
2389         buf_widx = tag_idx;
2390         tracks[track_widx].available -= 128;
2391         tracks[track_widx].filesize -= 128;
2392     }
2393
2394 strip_ape_tag:
2395     /* Check for APE tag (look for the APE tag footer) */
2396     tag_idx = RINGBUF_SUB(buf_widx, 32);
2397
2398     if (FILEBUFUSED > 32 && tag_idx > buf_ridx)
2399     {
2400         cur_idx = tag_idx;
2401         for(i = 0;i < 8;i++)
2402         {
2403             if(filebuf[cur_idx] != apetag[i])
2404                 return;
2405
2406             cur_idx = RINGBUF_ADD(cur_idx, 1);
2407         }
2408
2409         /* Read the version and length from the footer */
2410         version = filebuf[tag_idx+8] | (filebuf[tag_idx+9] << 8) |
2411                   (filebuf[tag_idx+10] << 16) | (filebuf[tag_idx+11] << 24);
2412         len = filebuf[tag_idx+12] | (filebuf[tag_idx+13] << 8) |
2413               (filebuf[tag_idx+14] << 16) | (filebuf[tag_idx+15] << 24);
2414         if (version == 2000)
2415             len += 32; /* APEv2 has a 32 byte header */
2416
2417         /* Skip APE tag */
2418         if (FILEBUFUSED > len)
2419         {
2420             logf("Skipping APE tag (%ldB)", len);
2421             buf_widx = RINGBUF_SUB(buf_widx, len);
2422             tracks[track_widx].available -= len;
2423             tracks[track_widx].filesize -= len;
2424         }
2425     }
2426 }
2427
2428 /* Returns true if a whole file is read, false otherwise */
2429 static bool audio_read_file(size_t minimum)
2430 {
2431     bool ret_val = false;
2432
2433     /* If we're called and no file is open, this is an error */
2434     if (current_fd < 0)
2435     {
2436         logf("Bad fd in arf");
2437         /* Give some hope of miraculous recovery by forcing a track reload */
2438         tracks[track_widx].filesize = 0;
2439         /* Stop this buffering run */
2440         return ret_val;
2441     }
2442
2443     trigger_cpu_boost();
2444     while (tracks[track_widx].filerem > 0)
2445     {
2446         size_t copy_n;
2447         int overlap;
2448         int rc;
2449
2450         /* copy_n is the largest chunk that is safe to read */
2451         copy_n = MIN(conf_filechunk, filebuflen - buf_widx);
2452
2453         /* buf_widx == buf_ridx is defined as buffer empty, not buffer full */
2454         if (RINGBUF_ADD_CROSS(buf_widx,copy_n,buf_ridx) >= 0)
2455             break;
2456
2457         /* rc is the actual amount read */
2458         rc = read(current_fd, &filebuf[buf_widx], copy_n);
2459
2460         if (rc < 0)
2461         {
2462             logf("File ended %ldB early", tracks[track_widx].filerem);
2463             tracks[track_widx].filesize -= tracks[track_widx].filerem;
2464             tracks[track_widx].filerem = 0;
2465             break;
2466         }
2467
2468         /* How much of the playing track did we overwrite */
2469         if (buf_widx == CUR_TI->buf_idx)
2470         {
2471             /* Special handling; zero or full overlap? */
2472             if (track_widx == track_ridx && CUR_TI->available == 0)
2473                 overlap = 0;
2474             else
2475                 overlap = rc;
2476         }
2477         else
2478             overlap = RINGBUF_ADD_CROSS(buf_widx,rc,CUR_TI->buf_idx);
2479
2480         if ((unsigned)rc > tracks[track_widx].filerem)
2481         {
2482             logf("Bad: rc-filerem=%ld, fixing", rc-tracks[track_widx].filerem);
2483             tracks[track_widx].filesize += rc - tracks[track_widx].filerem;
2484             tracks[track_widx].filerem = rc;
2485         }
2486
2487         /* Advance buffer */
2488         buf_widx = RINGBUF_ADD(buf_widx, rc);
2489         tracks[track_widx].available += rc;
2490         tracks[track_widx].filerem -= rc;
2491
2492         /* If we write into the playing track, adjust it's buffer info */
2493         if (overlap > 0)
2494         {
2495             CUR_TI->buf_idx += overlap;
2496             CUR_TI->start_pos += overlap;
2497         }
2498
2499         /* For a rebuffer, fill at least this minimum */
2500         if (minimum > (unsigned)rc)
2501             minimum -= rc;
2502         /* Let the codec process up to the watermark */
2503         /* Break immediately if this is a quick buffer, or there is an event */
2504         else if (minimum || audio_yield_codecs())
2505         {
2506             /* Exit quickly, but don't stop the overall buffering process */
2507             ret_val = true;
2508             break;
2509         }
2510     }
2511
2512     if (tracks[track_widx].filerem == 0)
2513     {
2514         logf("Finished buf:%ldB", tracks[track_widx].filesize);
2515         close(current_fd);
2516         current_fd = -1;
2517         audio_strip_tags();
2518
2519         track_widx++;
2520         track_widx &= MAX_TRACK_MASK;
2521
2522         tracks[track_widx].filesize = 0;
2523         return true;
2524     }
2525     else
2526     {
2527         logf("%s buf:%ldB", ret_val?"Quick":"Partially",
2528                 tracks[track_widx].filesize - tracks[track_widx].filerem);
2529         return ret_val;
2530     }
2531 }
2532
2533 static bool audio_loadcodec(bool start_play)
2534 {
2535     size_t size = 0;
2536     int fd;
2537     int rc;
2538     size_t copy_n;
2539     int prev_track;
2540     char codec_path[MAX_PATH]; /* Full path to codec */
2541
2542     const char * codec_fn =
2543         get_codec_filename(bufgetid3(tracks[track_widx].id3_hid).codectype);
2544     if (codec_fn == NULL)
2545         return false;
2546
2547     tracks[track_widx].codec_hid = 0;
2548
2549     if (start_play)
2550     {
2551         /* Load the codec directly from disk and save some memory. */
2552         track_ridx = track_widx;
2553         ci.filesize = CUR_TI->filesize;
2554         ci.id3 = &curtrack_id3;
2555         ci.taginfo_ready = &CUR_TI->taginfo_ready;
2556         ci.curpos = 0;
2557         LOGFQUEUE("codec > codec Q_CODEC_LOAD_DISK");
2558         queue_post(&codec_queue, Q_CODEC_LOAD_DISK, (intptr_t)codec_fn);
2559         return true;
2560     }
2561     else
2562     {
2563         /* If we already have another track than this one buffered */
2564         if (track_widx != track_ridx)
2565         {
2566             prev_track = (track_widx - 1) & MAX_TRACK_MASK;
2567
2568             /* If the previous codec is the same as this one, there is no need
2569              * to put another copy of it on the file buffer */
2570             if (get_codec_base_type(
2571                         bufgetid3(tracks[track_widx].id3_hid).codectype) ==
2572                 get_codec_base_type(
2573                         bufgetid3(tracks[prev_track].id3_hid).codectype)
2574                 && audio_codec_loaded)
2575             {
2576                 logf("Reusing prev. codec");
2577                 return true;
2578             }
2579         }
2580     }
2581
2582     codec_get_full_path(codec_path, codec_fn);
2583
2584     fd = open(codec_path, O_RDONLY);
2585     if (fd < 0)
2586     {
2587         logf("Codec doesn't exist!");
2588         return false;
2589     }
2590
2591     tracks[track_widx].codecsize = filesize(fd);
2592
2593     tracks[track_widx].codec_hid = bufopen(codec_path, TYPE_CODEC);
2594     if (tracks[track_widx].codec_hid < 0)
2595     {
2596         logf("Not enough space");
2597         close(fd);
2598         return false;
2599     }
2600
2601     tracks[track_widx].has_codec = true;
2602
2603     close(fd);
2604     logf("Done: %ldB", size);
2605
2606     return true;
2607 }
2608
2609 /* TODO: Copied from mpeg.c. Should be moved somewhere else. */
2610 static void audio_set_elapsed(struct mp3entry* id3)
2611 {
2612     unsigned long offset = id3->offset > id3->first_frame_offset ?
2613         id3->offset - id3->first_frame_offset : 0;
2614
2615     if ( id3->vbr ) {
2616         if ( id3->has_toc ) {
2617             /* calculate elapsed time using TOC */
2618             int i;
2619             unsigned int remainder, plen, relpos, nextpos;
2620
2621             /* find wich percent we're at */
2622             for (i=0; i<100; i++ )
2623                 if ( offset < id3->toc[i] * (id3->filesize / 256) )
2624                     break;
2625
2626             i--;
2627             if (i < 0)
2628                 i = 0;
2629
2630             relpos = id3->toc[i];
2631
2632             if (i < 99)
2633                 nextpos = id3->toc[i+1];
2634             else
2635                 nextpos = 256;
2636
2637             remainder = offset - (relpos * (id3->filesize / 256));
2638
2639             /* set time for this percent (divide before multiply to prevent
2640                overflow on long files. loss of precision is negligible on
2641                short files) */
2642             id3->elapsed = i * (id3->length / 100);
2643
2644             /* calculate remainder time */
2645             plen = (nextpos - relpos) * (id3->filesize / 256);
2646             id3->elapsed += (((remainder * 100) / plen) *
2647                              (id3->length / 10000));
2648         }
2649         else {
2650             /* no TOC exists. set a rough estimate using average bitrate */
2651             int tpk = id3->length /
2652                 ((id3->filesize - id3->first_frame_offset - id3->id3v1len) /
2653                 1024);
2654             id3->elapsed = offset / 1024 * tpk;
2655         }
2656     }
2657     else
2658     {
2659         /* constant bitrate, use exact calculation */
2660         if (id3->bitrate != 0)
2661             id3->elapsed = offset / (id3->bitrate / 8);
2662     }
2663 }
2664
2665 static bool audio_load_track(int offset, bool start_play, bool rebuffer)
2666 {
2667     char *trackname;
2668     off_t size;
2669     char msgbuf[80];
2670     int fd;
2671     struct mp3entry id3;
2672
2673     /* Stop buffer filling if there is no free track entries.
2674        Don't fill up the last track entry (we wan't to store next track
2675        metadata there). */
2676     if (!audio_have_free_tracks())
2677     {
2678         logf("No free tracks");
2679         return false;
2680     }
2681
2682     last_peek_offset++;
2683     peek_again:
2684     logf("Buffering track:%d/%d", track_widx, track_ridx);
2685     /* Get track name from current playlist read position. */
2686     while ((trackname = playlist_peek(last_peek_offset)) != NULL)
2687     {
2688         /* Handle broken playlists. */
2689         fd = open(trackname, O_RDONLY);
2690         if (fd < 0)
2691         {
2692             logf("Open failed");
2693             /* Skip invalid entry from playlist. */
2694             playlist_skip_entry(NULL, last_peek_offset);
2695         }
2696         else
2697             break;
2698     }
2699
2700     if (!trackname)
2701     {
2702         logf("End-of-playlist");
2703         playlist_end = true;
2704         return false;
2705     }
2706
2707     /* Initialize track entry. */
2708     size = filesize(fd);
2709     tracks[track_widx].filesize = size;
2710
2711     /* Set default values */
2712     if (start_play)
2713     {
2714         int last_codec = current_codec;
2715
2716         set_current_codec(CODEC_IDX_AUDIO);
2717         conf_watermark = AUDIO_DEFAULT_WATERMARK;
2718         conf_filechunk = AUDIO_DEFAULT_FILECHUNK;
2719         conf_preseek = AUDIO_REBUFFER_GUESS_SIZE;
2720         dsp_configure(DSP_RESET, 0);
2721         set_current_codec(last_codec);
2722     }
2723
2724     /* Get track metadata if we don't already have it. */
2725     if (!tracks[track_widx].taginfo_ready)
2726     {
2727         if (get_metadata(&id3, fd, trackname))
2728         {
2729             tracks[track_widx].taginfo_ready = true;
2730             tracks[track_widx].id3_hid = bufalloc(&id3, sizeof(struct mp3entry),
2731                                                   TYPE_ID3);
2732             if (start_play)
2733             {
2734                 track_changed = true;
2735                 playlist_update_resume_info(audio_current_track());
2736             }
2737         }
2738         else
2739         {
2740             logf("mde:%s!",trackname);
2741
2742             /* Skip invalid entry from playlist. */
2743             playlist_skip_entry(NULL, last_peek_offset);
2744             tracks[track_widx].taginfo_ready = false;
2745             goto peek_again;
2746         }
2747
2748     }
2749
2750 #if 0
2751     if (cuesheet_is_enabled() && tracks[track_widx].id3.cuesheet_type == 1)
2752     {
2753         char cuepath[MAX_PATH];
2754
2755         struct cuesheet *cue = start_play ? curr_cue : temp_cue;
2756
2757         if (look_for_cuesheet_file(trackname, cuepath) &&
2758             parse_cuesheet(cuepath, cue))
2759         {
2760             strcpy((cue)->audio_filename, trackname);
2761             if (start_play)
2762                 cue_spoof_id3(curr_cue, &tracks[track_widx].id3);
2763         }
2764     }
2765 #endif
2766
2767     /* Load the codec. */
2768     if (!audio_loadcodec(start_play))
2769     {
2770         /* Set filesize to zero to indicate no file was loaded. */
2771         tracks[track_widx].filesize = 0;
2772         tracks[track_widx].filerem = 0;
2773         close(current_fd);
2774         current_fd = -1;
2775
2776         if (tracks[track_widx].codecsize)
2777         {
2778             /* No space for codec on buffer, not an error */
2779             tracks[track_widx].codecsize = 0;
2780             return false;
2781         }
2782
2783         /* This is an error condition, either no codec was found, or reading
2784          * the codec file failed part way through, either way, skip the track */
2785         snprintf(msgbuf, sizeof(msgbuf)-1, "No codec for: %s", trackname);
2786         /* We should not use gui_syncplash from audio thread! */
2787         gui_syncsplash(HZ*2, msgbuf);
2788         /* Skip invalid entry from playlist. */
2789         playlist_skip_entry(NULL, last_peek_offset);
2790         tracks[track_widx].taginfo_ready = false;
2791         goto peek_again;
2792     }
2793
2794     tracks[track_widx].start_pos = 0;
2795     set_filebuf_watermark(buffer_margin);
2796     tracks[track_widx].id3.elapsed = 0;
2797
2798     if (offset > 0)
2799     {
2800         switch (tracks[track_widx].id3.codectype) {
2801         case AFMT_MPA_L1:
2802         case AFMT_MPA_L2:
2803         case AFMT_MPA_L3:
2804             lseek(current_fd, offset, SEEK_SET);
2805             tracks[track_widx].id3.offset = offset;
2806             audio_set_elapsed(&tracks[track_widx].id3);
2807             tracks[track_widx].filerem = size - offset;
2808             ci.curpos = offset;
2809             tracks[track_widx].start_pos = offset;
2810             break;
2811
2812         case AFMT_WAVPACK:
2813             lseek(current_fd, offset, SEEK_SET);
2814             tracks[track_widx].id3.offset = offset;
2815             tracks[track_widx].id3.elapsed =
2816                 tracks[track_widx].id3.length / 2;
2817             tracks[track_widx].filerem = size - offset;
2818             ci.curpos = offset;
2819             tracks[track_widx].start_pos = offset;
2820             break;
2821
2822         case AFMT_OGG_VORBIS:
2823         case AFMT_SPEEX:
2824         case AFMT_FLAC:
2825         case AFMT_PCM_WAV:
2826         case AFMT_A52:
2827         case AFMT_AAC:
2828         case AFMT_MPC:
2829         case AFMT_APE:
2830             tracks[track_widx].id3.offset = offset;
2831             break;
2832         }
2833     }
2834
2835     logf("alt:%s", trackname);
2836     tracks[track_widx].buf_idx = buf_widx;
2837
2838     return audio_read_file(rebuffer);
2839 }
2840
2841 static bool audio_read_next_metadata(void)
2842 {
2843     int fd;
2844     char *trackname;
2845     int next_idx;
2846     int status;
2847
2848     next_idx = track_widx;
2849     if (tracks[next_idx].taginfo_ready)
2850     {
2851         next_idx++;
2852         next_idx &= MAX_TRACK_MASK;
2853
2854         if (tracks[next_idx].taginfo_ready)
2855             return true;
2856     }
2857
2858     trackname = playlist_peek(last_peek_offset + 1);
2859     if (!trackname)
2860         return false;
2861
2862     fd = open(trackname, O_RDONLY);
2863     if (fd < 0)
2864         return false;
2865
2866     status = get_metadata(&(tracks[next_idx].id3),fd,trackname);
2867     /* Preload the glyphs in the tags */
2868     if (status)
2869     {
2870         tracks[next_idx].taginfo_ready = true;
2871         if (tracks[next_idx].id3.title)
2872             lcd_getstringsize(tracks[next_idx].id3.title, NULL, NULL);
2873         if (tracks[next_idx].id3.artist)
2874             lcd_getstringsize(tracks[next_idx].id3.artist, NULL, NULL);
2875         if (tracks[next_idx].id3.album)
2876             lcd_getstringsize(tracks[next_idx].id3.album, NULL, NULL);
2877     }
2878     close(fd);
2879
2880     return status;
2881 }
2882
2883 /* Send callback events to notify about new tracks. */
2884 static void audio_generate_postbuffer_events(void)
2885 {
2886     int cur_idx;
2887     int last_idx = -1;
2888
2889     logf("Postbuffer:%d/%d",track_ridx,track_widx);
2890
2891     if (audio_have_tracks())
2892     {
2893         cur_idx = track_ridx;
2894
2895         while (1) {
2896             if (!tracks[cur_idx].event_sent)
2897             {
2898                 if (last_idx >= 0 && !tracks[last_idx].event_sent)
2899                 {
2900                     /* Mark the event 'sent' even if we don't really send one */
2901                     tracks[last_idx].event_sent = true;
2902                     if (track_buffer_callback)
2903                         track_buffer_callback(&tracks[last_idx].id3, false);
2904                 }
2905                 last_idx = cur_idx;
2906             }
2907             if (cur_idx == track_widx)
2908                 break;
2909             cur_idx++;
2910             cur_idx &= MAX_TRACK_MASK;
2911         }
2912
2913         if (last_idx >= 0 && !tracks[last_idx].event_sent)
2914         {
2915             tracks[last_idx].event_sent = true;
2916             if (track_buffer_callback)
2917                 track_buffer_callback(&tracks[last_idx].id3, true);
2918         }
2919     }
2920 }
2921
2922 static bool audio_initialize_buffer_fill(bool clear_tracks)
2923 {
2924     /* Don't initialize if we're already initialized */
2925     if (filling)
2926         return true;
2927
2928     logf("Starting buffer fill");
2929
2930     /* Set the filling flag true before calling audio_clear_tracks as that
2931      * function can yield and we start looping. */
2932     filling = true;
2933
2934     if (clear_tracks)
2935         audio_clear_track_entries(false);
2936
2937     /* Save the current resume position once. */
2938     playlist_update_resume_info(audio_current_track());
2939
2940     return true;
2941 }
2942
2943 static void audio_fill_file_buffer(
2944         bool start_play, bool rebuffer, size_t offset)
2945 {
2946     bool had_next_track = audio_next_track() != NULL;
2947     bool continue_buffering;
2948
2949     /* Must reset the buffer before use if trashed or voice only - voice
2950        file size shouldn't have changed so we can go straight from
2951        BUFFER_STATE_VOICED_ONLY to BUFFER_STATE_INITIALIZED */
2952     if (buffer_state != BUFFER_STATE_INITIALIZED)
2953         audio_reset_buffer();
2954
2955     if (!audio_initialize_buffer_fill(!start_play))
2956         return ;
2957
2958     /* If we have a partially buffered track, continue loading,
2959      * otherwise load a new track */
2960     if (tracks[track_widx].filesize > 0)
2961         continue_buffering = audio_read_file(rebuffer);
2962     else
2963         continue_buffering = audio_load_track(offset, start_play, rebuffer);
2964
2965     if (!had_next_track && audio_next_track())
2966         track_changed = true;
2967
2968     /* If we're done buffering */
2969     if (!continue_buffering)
2970     {
2971         audio_read_next_metadata();
2972
2973         audio_generate_postbuffer_events();
2974         filling = false;
2975     }
2976 #ifndef SIMULATOR
2977     ata_sleep();
2978 #endif
2979
2980 }
2981
2982 static void audio_rebuffer(void)
2983 {
2984     logf("Forcing rebuffer");
2985
2986     /* Stop in progress fill, and clear open file descriptor */
2987     if (current_fd >= 0)
2988     {
2989         close(current_fd);
2990         current_fd = -1;
2991     }
2992     filling = false;
2993
2994     /* Reset buffer and track pointers */
2995     CUR_TI->buf_idx = buf_ridx = buf_widx = 0;
2996     track_widx = track_ridx;
2997     audio_clear_track_entries(true);
2998     CUR_TI->available = 0;
2999
3000     /* Fill the buffer */
3001     last_peek_offset = -1;
3002     CUR_TI->filesize = 0;
3003     CUR_TI->start_pos = 0;
3004     ci.curpos = 0;
3005
3006     if (!CUR_TI->taginfo_ready)
3007         memset(&curtrack_id3, 0, sizeof(struct mp3entry));
3008
3009     audio_fill_file_buffer(false, true, 0);
3010 }
3011
3012 static int audio_check_new_track(void)
3013 {
3014     int track_count = audio_track_count();
3015     int old_track_ridx = track_ridx;
3016     bool forward;
3017
3018     if (dir_skip)
3019     {
3020         dir_skip = false;
3021         if (playlist_next_dir(ci.new_track))
3022         {
3023             ci.new_track = 0;
3024             CUR_TI->taginfo_ready = false;
3025             audio_rebuffer();
3026             goto skip_done;
3027         }
3028         else
3029         {
3030             LOGFQUEUE("audio >|= codec Q_CODEC_REQUEST_FAILED");
3031             return Q_CODEC_REQUEST_FAILED;
3032         }
3033     }
3034
3035     if (new_playlist)
3036         ci.new_track = 0;
3037
3038     /* If the playlist isn't that big */
3039     if (!playlist_check(ci.new_track))
3040     {
3041         if (ci.new_track >= 0)
3042         {
3043             LOGFQUEUE("audio >|= codec Q_CODEC_REQUEST_FAILED");
3044             return Q_CODEC_REQUEST_FAILED;
3045         }
3046         /* Find the beginning backward if the user over-skips it */
3047         while (!playlist_check(++ci.new_track))
3048             if (ci.new_track >= 0)
3049             {
3050                 LOGFQUEUE("audio >|= codec Q_CODEC_REQUEST_FAILED");
3051                 return Q_CODEC_REQUEST_FAILED;
3052             }
3053     }
3054     /* Update the playlist */
3055     last_peek_offset -= ci.new_track;
3056
3057     if (playlist_next(ci.new_track) < 0)
3058     {
3059         LOGFQUEUE("audio >|= codec Q_CODEC_REQUEST_FAILED");
3060         return Q_CODEC_REQUEST_FAILED;
3061     }
3062
3063     if (new_playlist)
3064     {
3065         ci.new_track = 1;
3066         new_playlist = false;
3067     }
3068
3069     /* Save the old track */
3070     prev_ti = CUR_TI;
3071
3072     /* Move to the new track */
3073     track_ridx += ci.new_track;
3074     track_ridx &= MAX_TRACK_MASK;
3075
3076     if (automatic_skip)
3077         playlist_end = false;
3078
3079     track_changed = !automatic_skip;
3080
3081     /* If it is not safe to even skip this many track entries */
3082     if (ci.new_track >= track_count || ci.new_track <= track_count - MAX_TRACK)
3083     {
3084         ci.new_track = 0;
3085         CUR_TI->taginfo_ready = false;
3086         audio_rebuffer();
3087         goto skip_done;
3088     }
3089
3090     forward = ci.new_track > 0;
3091     ci.new_track = 0;
3092
3093     /* If the target track is clearly not in memory */
3094     if (CUR_TI->filesize == 0 || !CUR_TI->taginfo_ready)
3095     {
3096         audio_rebuffer();
3097         goto skip_done;
3098     }
3099
3100     /* The track may be in memory, see if it really is */
3101     if (forward)
3102     {
3103         if (!audio_buffer_wind_forward(track_ridx, old_track_ridx))
3104             audio_rebuffer();
3105     }
3106     else
3107     {
3108         int cur_idx = track_ridx;
3109         bool taginfo_ready = true;
3110         bool wrap = track_ridx > old_track_ridx;
3111
3112         while (1)
3113         {
3114             cur_idx++;
3115             cur_idx &= MAX_TRACK_MASK;
3116             if (!(wrap || cur_idx < old_track_ridx))
3117                 break;
3118
3119             /* If we hit a track in between without valid tag info, bail */
3120             if (!tracks[cur_idx].taginfo_ready)
3121             {
3122                 taginfo_ready = false;
3123                 break;
3124             }
3125
3126             tracks[cur_idx].available = tracks[cur_idx].filesize;
3127             if (tracks[cur_idx].codecsize)
3128                 tracks[cur_idx].has_codec = true;
3129         }
3130         if (taginfo_ready)
3131         {
3132             if (!audio_buffer_wind_backward(track_ridx, old_track_ridx))
3133                 audio_rebuffer();
3134         }
3135         else
3136         {
3137             CUR_TI->taginfo_ready = false;
3138             audio_rebuffer();
3139         }
3140     }
3141
3142 skip_done:
3143     audio_update_trackinfo();
3144     LOGFQUEUE("audio >|= codec Q_CODEC_REQUEST_COMPLETE");
3145     return Q_CODEC_REQUEST_COMPLETE;
3146 }
3147
3148 static int audio_rebuffer_and_seek(size_t newpos)
3149 {
3150     size_t real_preseek;
3151     int fd;
3152     char *trackname;
3153
3154     /* (Re-)open current track's file handle. */
3155     trackname = playlist_peek(0);
3156     fd = open(trackname, O_RDONLY);
3157     if (fd < 0)
3158     {
3159         LOGFQUEUE("audio >|= codec Q_CODEC_REQUEST_FAILED");
3160         return Q_CODEC_REQUEST_FAILED;
3161     }
3162
3163     if (current_fd >= 0)
3164         close(current_fd);
3165     current_fd = fd;
3166
3167     playlist_end = false;
3168
3169     ci.curpos = newpos;
3170
3171     /* Clear codec buffer. */
3172     track_widx = track_ridx;
3173     tracks[track_widx].buf_idx = buf_widx = buf_ridx = 0;
3174
3175     last_peek_offset = 0;
3176     filling = false;
3177     audio_initialize_buffer_fill(true);
3178
3179     /* This may have been tweaked by the id3v1 code */
3180     CUR_TI->filesize=filesize(fd);
3181     if (newpos > conf_preseek)
3182     {
3183         CUR_TI->start_pos = newpos - conf_preseek;
3184         lseek(current_fd, CUR_TI->start_pos, SEEK_SET);
3185         CUR_TI->filerem = CUR_TI->filesize - CUR_TI->start_pos;
3186         real_preseek = conf_preseek;
3187     }
3188     else
3189     {
3190         CUR_TI->start_pos = 0;
3191         CUR_TI->filerem = CUR_TI->filesize;
3192         real_preseek = newpos;
3193     }
3194
3195     CUR_TI->available = 0;
3196
3197     audio_read_file(real_preseek);
3198
3199     /* Account for the data we just read that is 'behind' us now */
3200     CUR_TI->available -= real_preseek;
3201
3202     buf_ridx = RINGBUF_ADD(buf_ridx, real_preseek);
3203
3204     LOGFQUEUE("audio >|= codec Q_CODEC_REQUEST_COMPLETE");
3205     return Q_CODEC_REQUEST_COMPLETE;
3206 }
3207
3208 void audio_set_track_buffer_event(void (*handler)(struct mp3entry *id3,
3209                                                   bool last_track))
3210 {
3211     track_buffer_callback = handler;
3212 }
3213
3214 void audio_set_track_unbuffer_event(void (*handler)(struct mp3entry *id3,
3215                                                     bool last_track))
3216 {
3217     track_unbuffer_callback = handler;
3218 }
3219
3220 void audio_set_track_changed_event(void (*handler)(struct mp3entry *id3))
3221 {
3222     track_changed_callback = handler;
3223 }
3224
3225 unsigned long audio_prev_elapsed(void)
3226 {
3227     return prev_track_elapsed;
3228 }
3229
3230 static void audio_stop_codec_flush(void)
3231 {
3232     ci.stop_codec = true;
3233     pcmbuf_pause(true);
3234
3235     while (audio_codec_loaded)
3236         yield();
3237
3238     /* If the audio codec is not loaded any more, and the audio is still
3239      * playing, it is now and _only_ now safe to call this function from the
3240      * audio thread */
3241     if (pcm_is_playing())
3242         pcmbuf_play_stop();
3243     pcmbuf_pause(paused);
3244 }
3245
3246 static void audio_stop_playback(void)
3247 {
3248     /* If we were playing, save resume information */
3249     if (playing)
3250     {
3251         struct mp3entry *id3 = NULL;
3252
3253         if (!playlist_end || !ci.stop_codec)
3254         {
3255             /* Set this early, the outside code yields and may allow the codec
3256                to try to wait for a reply on a buffer wait */
3257             ci.stop_codec = true;
3258             id3 = audio_current_track();
3259         }
3260
3261         /* Save the current playing spot, or NULL if the playlist has ended */
3262         playlist_update_resume_info(id3);
3263
3264         prev_track_elapsed = curtrack_id3.elapsed;
3265
3266         /* Increment index so runtime info is saved in audio_clear_track_entries().
3267          * Done here, as audio_stop_playback() may be called more than once.
3268          * Don't update runtime unless playback is stopped because of end of playlist.
3269          * Updating runtime when manually stopping a tracks, can destroy autoscores
3270          * and playcounts.
3271          */
3272         if (playlist_end)
3273         {
3274             track_ridx++;
3275             track_ridx &= MAX_TRACK_MASK;
3276         }
3277     }
3278
3279     filling = false;
3280     paused = false;
3281     audio_stop_codec_flush();
3282     playing = false;
3283
3284     if (current_fd >= 0)
3285     {
3286         close(current_fd);
3287         current_fd = -1;
3288     }
3289
3290     /* Mark all entries null. */
3291     audio_clear_track_entries(false);
3292 }
3293
3294 static void audio_play_start(size_t offset)
3295 {
3296 #if INPUT_SRC_CAPS != 0
3297     audio_set_input_source(AUDIO_SRC_PLAYBACK, SRCF_PLAYBACK);
3298     audio_set_output_source(AUDIO_SRC_PLAYBACK);
3299 #endif
3300
3301     /* Wait for any previously playing audio to flush - TODO: Not necessary? */
3302     paused = false;
3303     audio_stop_codec_flush();
3304
3305     track_changed = true;
3306     playlist_end = false;
3307
3308     playing = true;
3309
3310     ci.new_track = 0;
3311     ci.seek_time = 0;
3312     wps_offset = 0;
3313
3314     if (current_fd >= 0)
3315     {
3316         close(current_fd);
3317         current_fd = -1;
3318     }
3319
3320     sound_set_volume(global_settings.volume);
3321     track_widx = track_ridx = 0;
3322
3323     /* Mark all entries null. */
3324     memset(tracks, 0, sizeof(struct track_info) * MAX_TRACK);
3325
3326     last_peek_offset = -1;
3327
3328     /* Officially playing */
3329     queue_reply(&audio_queue, 1);
3330
3331     audio_fill_file_buffer(true, false, offset);
3332
3333     LOGFQUEUE("audio > audio Q_AUDIO_TRACK_CHANGED");
3334     queue_post(&audio_queue, Q_AUDIO_TRACK_CHANGED, 0);
3335 }
3336
3337
3338 /* Invalidates all but currently playing track. */
3339 static void audio_invalidate_tracks(void)
3340 {
3341     if (audio_have_tracks())
3342     {
3343         last_peek_offset = 0;
3344         playlist_end = false;
3345         track_widx = track_ridx;
3346
3347         /* Mark all other entries null (also buffered wrong metadata). */
3348         audio_clear_track_entries(true);
3349
3350         /* If the current track is fully buffered, advance the write pointer */
3351         if (tracks[track_widx].filerem == 0)
3352             track_widx = (track_widx + 1) & MAX_TRACK_MASK;
3353
3354         buf_widx = RINGBUF_ADD(buf_ridx, CUR_TI->available);
3355
3356         audio_read_next_metadata();
3357     }
3358 }
3359
3360 static void audio_new_playlist(void)
3361 {
3362     /* Prepare to start a new fill from the beginning of the playlist */
3363     last_peek_offset = -1;
3364     if (audio_have_tracks())
3365     {
3366         if (paused)
3367             skipped_during_pause = true;
3368         playlist_end = false;
3369         track_widx = track_ridx;
3370         audio_clear_track_entries(true);
3371
3372         track_widx++;
3373         track_widx &= MAX_TRACK_MASK;
3374
3375         /* Stop reading the current track */
3376         CUR_TI->filerem = 0;
3377         close(current_fd);
3378         current_fd = -1;
3379
3380         /* Mark the current track as invalid to prevent skipping back to it */
3381         CUR_TI->taginfo_ready = false;
3382
3383         /* Invalidate the buffer other than the playing track */
3384         buf_widx = RINGBUF_ADD(buf_ridx, CUR_TI->available);
3385     }
3386
3387     /* Signal the codec to initiate a track change forward */
3388     new_playlist = true;
3389     ci.new_track = 1;
3390
3391     /* Officially playing */
3392     queue_reply(&audio_queue, 1);
3393
3394     audio_fill_file_buffer(false, true, 0);
3395 }
3396
3397 static void audio_initiate_track_change(long direction)
3398 {
3399     playlist_end = false;
3400     ci.new_track += direction;
3401     wps_offset -= direction;
3402     if (paused)
3403         skipped_during_pause = true;
3404 }
3405
3406 static void audio_initiate_dir_change(long direction)
3407 {
3408     playlist_end = false;
3409     dir_skip = true;
3410     ci.new_track = direction;
3411     if (paused)
3412         skipped_during_pause = true;
3413 }
3414
3415 /*
3416  * Layout audio buffer as follows - iram buffer depends on target:
3417  * [|SWAP:iram][|TALK]|MALLOC|FILE|GUARD|PCM|[SWAP:dram[|iram]|]
3418  */
3419 static void audio_reset_buffer(void)
3420 {
3421     /* see audio_get_recording_buffer if this is modified */
3422     logf("audio_reset_buffer");
3423
3424     /* If the setup of anything allocated before the file buffer is
3425        changed, do check the adjustments after the buffer_alloc call
3426        as it will likely be affected and need sliding over */
3427
3428     /* Initially set up file buffer as all space available */
3429     malloc_buf = audiobuf + talk_get_bufsize();
3430     /* Align the malloc buf to line size. Especially important to cf
3431        targets that do line reads/writes. */
3432     malloc_buf = (unsigned char *)(((uintptr_t)malloc_buf + 15) & ~15);
3433     filebuf    = malloc_buf + MALLOC_BUFSIZE; /* filebuf line align implied */
3434     filebuflen = audiobufend - filebuf;
3435
3436     /* Allow for codec swap space at end of audio buffer */
3437     if (talk_voice_required())
3438     {
3439         /* Layout of swap buffer:
3440          * #ifdef IRAM_STEAL (dedicated iram_buf):
3441          *      |iram_buf|...audiobuf...|dram_buf|audiobufend
3442          * #else:
3443          *      audiobuf...|dram_buf|iram_buf|audiobufend
3444          */
3445 #ifdef PLAYBACK_VOICE
3446         /* Check for an absolutely nasty situation which should never,
3447            ever happen - frankly should just panic */
3448         if (voice_codec_loaded && current_codec != CODEC_IDX_VOICE)
3449         {
3450             logf("buffer reset with voice swapped");
3451         }
3452         /* line align length which line aligns the calculations below since
3453            all sizes are also at least line aligned - needed for memswap128 */
3454         filebuflen &= ~15;
3455 #ifdef IRAM_STEAL
3456         filebuflen -= CODEC_SIZE;
3457 #else
3458         filebuflen -= CODEC_SIZE + CODEC_IRAM_SIZE;
3459 #endif
3460         /* Allocate buffers for swapping voice <=> audio */
3461         /* If using IRAM for plugins voice IRAM swap buffer must be dedicated
3462            and out of the way of buffer usage or else a call to audio_get_buffer
3463            and subsequent buffer use might trash the swap space. A plugin
3464            initializing IRAM after getting the full buffer would present similar
3465            problem. Options include: failing the request if the other buffer
3466            has been obtained already or never allowing use of the voice IRAM
3467            buffer within the audio buffer. Using buffer_alloc basically
3468            implements the second in a more convenient way. */
3469         dram_buf = filebuf + filebuflen;
3470
3471 #ifdef IRAM_STEAL
3472         /* Allocate voice IRAM swap buffer once */
3473         if (iram_buf == NULL)
3474         {
3475             iram_buf = buffer_alloc(CODEC_IRAM_SIZE);
3476             /* buffer_alloc moves audiobuf; this is safe because only the end
3477              * has been touched so far in this function and the address of
3478              * filebuf + filebuflen is not changed */
3479             malloc_buf += CODEC_IRAM_SIZE;
3480             filebuf    += CODEC_IRAM_SIZE;
3481             filebuflen -= CODEC_IRAM_SIZE;
3482         }
3483 #else
3484         /* Allocate iram_buf after dram_buf */
3485         iram_buf = dram_buf + CODEC_SIZE;
3486 #endif /* IRAM_STEAL */
3487 #endif /* PLAYBACK_VOICE */
3488     }
3489     else
3490     {
3491 #ifdef PLAYBACK_VOICE
3492         /* No swap buffers needed */
3493         iram_buf = NULL;
3494         dram_buf = NULL;
3495 #endif
3496     }
3497
3498     /* Subtract whatever the pcm buffer says it used plus the guard buffer */
3499     filebuflen -= pcmbuf_init(filebuf + filebuflen) + GUARD_BUFSIZE;
3500
3501     /* Make sure filebuflen is a longword multiple after adjustment - filebuf
3502        will already be line aligned */
3503     filebuflen &= ~3;
3504
3505     /* Set the high watermark as 75% full...or 25% empty :) */
3506 #if MEM > 8
3507     high_watermark = 3*filebuflen / 4;
3508 #endif
3509
3510     /* Clear any references to the file buffer */
3511     buffer_state = BUFFER_STATE_INITIALIZED;
3512
3513 #if defined(ROCKBOX_HAS_LOGF) && defined(LOGF_ENABLE)
3514     /* Make sure everything adds up - yes, some info is a bit redundant but
3515        aids viewing and the sumation of certain variables should add up to
3516        the location of others. */
3517     {
3518         size_t pcmbufsize;
3519         unsigned char * pcmbuf = pcmbuf_get_meminfo(&pcmbufsize);
3520         logf("mabuf:  %08X", (unsigned)malloc_buf);
3521         logf("mabufe: %08X", (unsigned)(malloc_buf + MALLOC_BUFSIZE));
3522         logf("fbuf:   %08X", (unsigned)filebuf);
3523         logf("fbufe:  %08X", (unsigned)(filebuf + filebuflen));
3524         logf("gbuf:   %08X", (unsigned)(filebuf + filebuflen));
3525         logf("gbufe:  %08X", (unsigned)(filebuf + filebuflen + GUARD_BUFSIZE));
3526         logf("pcmb:   %08X", (unsigned)pcmbuf);
3527         logf("pcmbe:  %08X", (unsigned)(pcmbuf + pcmbufsize));
3528         if (dram_buf)
3529         {
3530             logf("dramb:  %08X", (unsigned)dram_buf);
3531             logf("drambe: %08X", (unsigned)(dram_buf + CODEC_SIZE));
3532         }
3533         if (iram_buf)
3534         {
3535             logf("iramb:  %08X", (unsigned)iram_buf);
3536             logf("irambe:  %08X", (unsigned)(iram_buf + CODEC_IRAM_SIZE));
3537         }
3538     }
3539 #endif
3540 }
3541
3542 #if MEM > 8
3543 /* we dont want this rebuffering on targets with little ram
3544    because the disk may never spin down */
3545 static bool ata_fillbuffer_callback(void)
3546 {
3547     queue_post(&audio_queue, Q_AUDIO_FILL_BUFFER_IF_ACTIVE_ATA, 0);
3548     return true;
3549 }
3550 #endif
3551
3552 static void audio_thread(void)
3553 {
3554     struct queue_event ev;
3555
3556     pcm_postinit();
3557
3558 #ifdef PLAYBACK_VOICE
3559     /* Unlock semaphore that init stage locks before creating this thread */
3560     semaphore_release(&sem_codecthread);
3561
3562     /* Buffers must be set up by now - should panic - really */
3563     if (buffer_state != BUFFER_STATE_INITIALIZED)
3564     {
3565         logf("audio_thread start: no buffer");
3566     }
3567
3568     /* Have to wait for voice to load up or else the codec swap will be
3569        invalid when an audio codec is loaded */
3570     wait_for_voice_swap_in();
3571 #endif
3572
3573     while (1)
3574     {
3575         if (filling)
3576         {
3577             queue_wait_w_tmo(&audio_queue, &ev, 0);
3578             if (ev.id == SYS_TIMEOUT)
3579                 ev.id = Q_AUDIO_FILL_BUFFER;
3580         }
3581         else
3582         {
3583             queue_wait_w_tmo(&audio_queue, &ev, HZ/2);
3584 #if MEM > 8
3585             if (playing && (ev.id == SYS_TIMEOUT) &&
3586                 (FILEBUFUSED < high_watermark))
3587                 register_ata_idle_func(ata_fillbuffer_callback);
3588 #endif
3589         }
3590
3591         switch (ev.id) {
3592 #if MEM > 8
3593             case Q_AUDIO_FILL_BUFFER_IF_ACTIVE_ATA:
3594                  /* only fill if the disk is still spining */
3595 #ifndef SIMULATOR
3596                  if (!ata_disk_is_active())
3597                     break;
3598 #endif
3599 #endif /* MEM > 8 */
3600                   /* else fall through to Q_AUDIO_FILL_BUFFER */
3601             case Q_AUDIO_FILL_BUFFER:
3602                 LOGFQUEUE("audio < Q_AUDIO_FILL_BUFFER");
3603                 if (!filling)
3604                     if (!playing || playlist_end || ci.stop_codec)
3605                         break;
3606                 audio_fill_file_buffer(false, false, 0);
3607                 break;
3608
3609             case Q_AUDIO_PLAY:
3610                 LOGFQUEUE("audio < Q_AUDIO_PLAY");
3611                 if (playing && ev.data <= 0)
3612                     audio_new_playlist();
3613                 else
3614                 {
3615                     audio_stop_playback();
3616                     audio_play_start((size_t)ev.data);
3617                 }
3618                 break;
3619
3620             case Q_AUDIO_STOP:
3621                 LOGFQUEUE("audio < Q_AUDIO_STOP");
3622                 if (playing)
3623                     audio_stop_playback();
3624                 if (ev.data != 0)
3625                     queue_clear(&audio_queue);
3626                 break;
3627
3628             case Q_AUDIO_PAUSE:
3629                 LOGFQUEUE("audio < Q_AUDIO_PAUSE");
3630                 if (!(bool) ev.data && skipped_during_pause && !pcmbuf_is_crossfade_active())
3631                     pcmbuf_play_stop(); /* Flush old track on resume after skip */
3632                 skipped_during_pause = false;
3633                 if (!playing)
3634                     break;
3635                 pcmbuf_pause((bool)ev.data);
3636                 paused = (bool)ev.data;
3637                 break;
3638
3639             case Q_AUDIO_SKIP:
3640                 LOGFQUEUE("audio < Q_AUDIO_SKIP");
3641                 audio_initiate_track_change((long)ev.data);
3642                 break;
3643
3644             case Q_AUDIO_PRE_FF_REWIND:
3645                 LOGFQUEUE("audio < Q_AUDIO_PRE_FF_REWIND");
3646                 if (!playing)
3647                     break;
3648                 pcmbuf_pause(true);
3649                 break;
3650
3651             case Q_AUDIO_FF_REWIND:
3652                 LOGFQUEUE("audio < Q_AUDIO_FF_REWIND");
3653                 if (!playing)
3654                     break;
3655                 ci.seek_time = (long)ev.data+1;
3656                 break;
3657
3658             case Q_AUDIO_REBUFFER_SEEK:
3659                 LOGFQUEUE("audio < Q_AUDIO_REBUFFER_SEEK");
3660                 queue_reply(&audio_queue, audio_rebuffer_and_seek(ev.data));
3661                 break;
3662
3663             case Q_AUDIO_CHECK_NEW_TRACK:
3664                 LOGFQUEUE("audio < Q_AUDIO_CHECK_NEW_TRACK");
3665                 queue_reply(&audio_queue, audio_check_new_track());
3666                 break;
3667
3668             case Q_AUDIO_DIR_SKIP:
3669                 LOGFQUEUE("audio < Q_AUDIO_DIR_SKIP");
3670                 playlist_end = false;
3671                 audio_initiate_dir_change(ev.data);
3672                 break;
3673
3674             case Q_AUDIO_FLUSH:
3675                 LOGFQUEUE("audio < Q_AUDIO_FLUSH");
3676                 audio_invalidate_tracks();
3677                 break;
3678
3679             case Q_AUDIO_TRACK_CHANGED:
3680                 LOGFQUEUE("audio < Q_AUDIO_TRACK_CHANGED");
3681                 if (track_changed_callback)
3682                     track_changed_callback(&curtrack_id3);
3683                 track_changed = true;
3684                 playlist_update_resume_info(audio_current_track());
3685                 break;
3686
3687 #ifndef SIMULATOR
3688             case SYS_USB_CONNECTED:
3689                 LOGFQUEUE("audio < SYS_USB_CONNECTED");
3690                 if (playing)
3691                     audio_stop_playback();
3692                 usb_acknowledge(SYS_USB_CONNECTED_ACK);
3693                 usb_wait_for_disconnect(&audio_queue);
3694                 break;
3695 #endif
3696
3697             case SYS_TIMEOUT:
3698                 LOGFQUEUE_SYS_TIMEOUT("audio < SYS_TIMEOUT");
3699                 break;
3700
3701             default:
3702                 LOGFQUEUE("audio < default");
3703         } /* end switch */
3704     } /* end while */
3705 }
3706
3707 #ifdef ROCKBOX_HAS_LOGF
3708 static void audio_test_track_changed_event(struct mp3entry *id3)
3709 {
3710     (void)id3;
3711
3712     logf("tce:%s", id3->path);
3713 }
3714 #endif
3715
3716 /* Initialize the audio system - called from init() in main.c.
3717  * Last function because of all the references to internal symbols
3718  */
3719 void audio_init(void)
3720 {
3721 #ifdef PLAYBACK_VOICE
3722     static bool voicetagtrue = true;
3723     static struct mp3entry id3_voice;
3724     struct thread_entry *voice_thread_p = NULL;
3725 #endif
3726     struct thread_entry *audio_thread_p;
3727
3728     /* Can never do this twice */
3729     if (audio_is_initialized)
3730     {
3731         logf("audio: already initialized");
3732         return;
3733     }
3734
3735     logf("audio: initializing");
3736
3737     /* Initialize queues before giving control elsewhere in case it likes
3738        to send messages. Thread creation will be delayed however so nothing
3739        starts running until ready if something yields such as talk_init. */
3740 #ifdef PLAYBACK_VOICE
3741     /* Take ownership of lock to prevent playback of anything before audio
3742        hardware is initialized - audio thread unlocks it after final init
3743        stage */
3744     semaphore_init(&sem_codecthread, 1, 0);
3745     event_init(&event_codecthread, EVENT_MANUAL | STATE_SIGNALED);
3746 #endif
3747     queue_init(&audio_queue, true);
3748     queue_enable_queue_send(&audio_queue, &audio_queue_sender_list);
3749     queue_init(&codec_queue, true);
3750
3751     pcm_init();
3752
3753 #ifdef ROCKBOX_HAS_LOGF
3754     audio_set_track_changed_event(audio_test_track_changed_event);
3755 #endif
3756
3757      /* Initialize codec api. */
3758     ci.read_filebuf        = codec_filebuf_callback;
3759     ci.pcmbuf_insert       = codec_pcmbuf_insert_callback;
3760     ci.get_codec_memory    = codec_get_memory_callback;
3761     ci.request_buffer      = codec_request_buffer_callback;
3762     ci.advance_buffer      = codec_advance_buffer_callback;
3763     ci.advance_buffer_loc  = codec_advance_buffer_loc_callback;
3764     ci.request_next_track  = codec_request_next_track_callback;
3765     ci.mp3_get_filepos     = codec_mp3_get_filepos_callback;
3766     ci.seek_buffer         = codec_seek_buffer_callback;
3767     ci.seek_complete       = codec_seek_complete_callback;
3768     ci.set_elapsed         = codec_set_elapsed_callback;
3769     ci.set_offset          = codec_set_offset_callback;
3770     ci.configure           = codec_configure_callback;
3771     ci.discard_codec       = codec_discard_codec_callback;
3772
3773      /* Initialize voice codec api. */
3774 #ifdef PLAYBACK_VOICE
3775     memcpy(&ci_voice, &ci, sizeof(ci_voice));
3776     memset(&id3_voice, 0, sizeof(id3_voice));
3777     ci_voice.read_filebuf        = voice_filebuf_callback;
3778     ci_voice.pcmbuf_insert       = voice_pcmbuf_insert_callback;
3779     ci_voice.get_codec_memory    = voice_get_memory_callback;
3780     ci_voice.request_buffer      = voice_request_buffer_callback;
3781     ci_voice.advance_buffer      = voice_advance_buffer_callback;
3782     ci_voice.advance_buffer_loc  = voice_advance_buffer_loc_callback;
3783     ci_voice.request_next_track  = voice_request_next_track_callback;
3784     ci_voice.mp3_get_filepos     = voice_mp3_get_filepos_callback;
3785     ci_voice.seek_buffer         = voice_seek_buffer_callback;
3786     ci_voice.seek_complete       = voice_do_nothing;
3787     ci_voice.set_elapsed         = voice_set_elapsed_callback;
3788     ci_voice.set_offset          = voice_set_offset_callback;
3789     ci_voice.configure           = voice_configure_callback;
3790     ci_voice.discard_codec       = voice_do_nothing;
3791     ci_voice.taginfo_ready       = &voicetagtrue;
3792     ci_voice.id3                 = &id3_voice;
3793     id3_voice.frequency          = 11200;
3794     id3_voice.length             = 1000000L;
3795 #endif
3796
3797     /* initialize the buffer */
3798     filebuf = audiobuf;
3799
3800     /* audio_reset_buffer must to know the size of voice buffer so init
3801        talk first */
3802     talk_init();
3803
3804     codec_thread_p = create_thread(
3805             codec_thread, codec_stack, sizeof(codec_stack),
3806             CREATE_THREAD_FROZEN,
3807             codec_thread_name IF_PRIO(, PRIORITY_PLAYBACK)
3808             IF_COP(, CPU));
3809
3810     audio_thread_p = create_thread(audio_thread, audio_stack,
3811                   sizeof(audio_stack), CREATE_THREAD_FROZEN,
3812                   audio_thread_name IF_PRIO(, PRIORITY_BUFFERING)
3813                   IF_COP(, CPU));
3814
3815     buffering_thread_p = create_thread( buffering_thread, buffering_stack,
3816             sizeof(buffering_stack), CREATE_THREAD_FROZEN,
3817             buffering_thread_name IF_PRIO(, PRIORITY_BUFFERING)
3818             IF_COP(, CPU, true));
3819
3820 #ifdef PLAYBACK_VOICE
3821     /* TODO: Change this around when various speech codecs can be used */
3822     if (talk_voice_required())
3823     {
3824         logf("Starting voice codec");
3825         queue_init(&voice_queue, true);
3826         voice_thread_p = create_thread(voice_thread, voice_stack,
3827                 sizeof(voice_stack), CREATE_THREAD_FROZEN,
3828                 voice_thread_name
3829                 IF_PRIO(, PRIORITY_PLAYBACK) IF_COP(, CPU));
3830     }
3831 #endif
3832
3833     /* Set crossfade setting for next buffer init which should be about... */
3834     pcmbuf_crossfade_enable(global_settings.crossfade);
3835
3836     /* ...now! Set up the buffers */
3837     audio_reset_buffer();
3838
3839     buffering_init(filebuf, filebuflen);
3840
3841     /* Probably safe to say */
3842     audio_is_initialized = true;
3843
3844     sound_settings_apply();
3845 #ifdef HAVE_WM8758
3846     eq_hw_enable(global_settings.eq_hw_enabled);
3847 #endif
3848 #ifndef HAVE_FLASH_STORAGE
3849     audio_set_buffer_margin(global_settings.buffer_margin);
3850 #endif
3851
3852     /* it's safe to let the threads run now */
3853     thread_thaw(codec_thread_p);
3854 #ifdef PLAYBACK_VOICE
3855     if (voice_thread_p)
3856         thread_thaw(voice_thread_p);
3857 #endif
3858     thread_thaw(audio_thread_p);
3859     thread_thaw(buffering_thread_p);
3860 } /* audio_init */
3861