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