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