apps/playback.c

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