apps/playback.c

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