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  * Copyright (C) 2011      Michael Sevakis
  13  *
  14  * This program is free software; you can redistribute it and/or
  15  * modify it under the terms of the GNU General Public License
  16  * as published by the Free Software Foundation; either version 2
  17  * of the License, or (at your option) any later version.
  18  *
  19  * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY
  20  * KIND, either express or implied.
  21  *
  22  ****************************************************************************/
  23 #include "config.h"
  24 #include "system.h"
  25 #include "kernel.h"
  26 #include "panic.h"
  27 #include "core_alloc.h"
  28 #include "sound.h"
  29 #include "ata.h"
  30 #include "usb.h"
  31 #include "codecs.h"
  32 #include "codec_thread.h"
  33 #include "voice_thread.h"
  34 #include "metadata.h"
  35 #include "cuesheet.h"
  36 #include "buffering.h"
  37 #include "talk.h"
  38 #include "playlist.h"
  39 #include "abrepeat.h"
  40 #include "pcmbuf.h"
  41 #include "playback.h"
  42 #include "misc.h"
  43 #include "settings.h"
  44
  45 #ifdef HAVE_TAGCACHE
  46 #include "tagcache.h"
  47 #endif
  48
  49 #ifdef AUDIO_HAVE_RECORDING
  50 #include "pcm_record.h"
  51 #endif
  52
  53 #ifdef HAVE_LCD_BITMAP
  54 #ifdef HAVE_ALBUMART
  55 #include "albumart.h"
  56 #endif
  57 #endif
  58
  59 /* TODO: The audio thread really is doing multitasking of acting like a
  60          consumer and producer of tracks. It may be advantageous to better
  61          logically separate the two functions. I won't go that far just yet. */
  62
  63 /* Internal support for voice playback */
  64 #define PLAYBACK_VOICE
  65
  66 #if CONFIG_PLATFORM & PLATFORM_NATIVE
  67 /* Application builds don't support direct code loading */
  68 #define HAVE_CODEC_BUFFERING
  69 #endif
  70
  71 /* Amount of guess-space to allow for codecs that must hunt and peck
  72  * for their correct seek target, 32k seems a good size */
  73 #define AUDIO_REBUFFER_GUESS_SIZE    (1024*32)
  74
  75 /* Define LOGF_ENABLE to enable logf output in this file */
  76 /* #define LOGF_ENABLE */
  77 #include "logf.h"
  78
  79 /* Macros to enable logf for queues
  80    logging on SYS_TIMEOUT can be disabled */
  81 #ifdef SIMULATOR
  82 /* Define this for logf output of all queuing except SYS_TIMEOUT */
  83 #define PLAYBACK_LOGQUEUES
  84 /* Define this to logf SYS_TIMEOUT messages */
  85 /*#define PLAYBACK_LOGQUEUES_SYS_TIMEOUT*/
  86 #endif
  87
  88 #ifdef PLAYBACK_LOGQUEUES
  89 #define LOGFQUEUE logf
  90 #else
  91 #define LOGFQUEUE(...)
  92 #endif
  93
  94 #ifdef PLAYBACK_LOGQUEUES_SYS_TIMEOUT
  95 #define LOGFQUEUE_SYS_TIMEOUT logf
  96 #else
  97 #define LOGFQUEUE_SYS_TIMEOUT(...)
  98 #endif
  99
 100 /* Variables are commented with the threads that use them:
 101  * A=audio, C=codec, O=other. A suffix of "-" indicates that the variable is
 102  * read but not updated on that thread. Audio is the only user unless otherwise
 103  * specified.
 104  */
 105
 106 /** Miscellaneous **/
 107 bool audio_is_initialized = false; /* (A,O-) */
 108 extern struct codec_api ci;        /* (A,C) */
 109
 110 /** Possible arrangements of the main buffer **/
 111 static enum audio_buffer_state
 112 {
 113     AUDIOBUF_STATE_TRASHED     = -1,     /* trashed; must be reset */
 114     AUDIOBUF_STATE_INITIALIZED =  0,     /* voice+audio OR audio-only */
 115     AUDIOBUF_STATE_VOICED_ONLY =  1,     /* voice-only */
 116 } buffer_state = AUDIOBUF_STATE_TRASHED; /* (A,O) */
 117
 118 /** Main state control **/
 119 static bool ff_rw_mode SHAREDBSS_ATTR = false; /* Pre-ff-rewind mode (A,O-) */
 120
 121 enum play_status
 122 {
 123     PLAY_STOPPED = 0,
 124     PLAY_PLAYING = AUDIO_STATUS_PLAY,
 125     PLAY_PAUSED  = AUDIO_STATUS_PLAY | AUDIO_STATUS_PAUSE,
 126 } play_status = PLAY_STOPPED;
 127
 128 /* Sizeable things that only need exist during playback and not when stopped */
 129 static struct audio_scratch_memory
 130 {
 131     struct mp3entry codec_id3; /* (A,C) */
 132     struct mp3entry unbuffered_id3;
 133     struct cuesheet *curr_cue; /* Will follow this structure */
 134 } * audio_scratch_memory = NULL;
 135
 136 /* These are used to store the current, next and optionally the peek-ahead
 137  * mp3entry's - this guarantees that the pointer returned by audio_current/
 138  * next_track will be valid for the full duration of the currently playing
 139  * track */
 140 enum audio_id3_types
 141 {
 142     /* These are allocated statically */
 143     PLAYING_ID3 = 0,
 144     NEXTTRACK_ID3,
 145 #ifdef AUDIO_FAST_SKIP_PREVIEW
 146     /* The real playing metadata must has to be protected since it contains
 147        critical info for other features */
 148     PLAYING_PEEK_ID3,
 149 #endif
 150     ID3_TYPE_NUM_STATIC,
 151     /* These go in the scratch memory */
 152     UNBUFFERED_ID3 = ID3_TYPE_NUM_STATIC,
 153     CODEC_ID3,
 154 };
 155 static struct mp3entry static_id3_entries[ID3_TYPE_NUM_STATIC]; /* (A,O) */
 156
 157 /* Peeking functions can yield and mess us up */
 158 static struct mutex id3_mutex SHAREDBSS_ATTR; /* (A,O)*/
 159
 160
 161 /** For Scrobbler support **/
 162
 163 /* Previous track elapsed time */
 164 static unsigned long prev_track_elapsed = 0; /* (A,O-) */
 165
 166
 167 /** For album art support **/
 168 #define MAX_MULTIPLE_AA SKINNABLE_SCREENS_COUNT
 169 #ifdef HAVE_ALBUMART
 170
 171 static struct albumart_slot
 172 {
 173     struct dim dim;     /* Holds width, height of the albumart */
 174     int used;           /* Counter; increments if something uses it */
 175 } albumart_slots[MAX_MULTIPLE_AA]; /* (A,O) */
 176
 177 #define FOREACH_ALBUMART(i) for(i = 0;i < MAX_MULTIPLE_AA; i++)
 178 #endif /* HAVE_ALBUMART */
 179
 180
 181 /** Information used for tracking buffer fills **/
 182
 183 /* Buffer and thread state tracking */
 184 static enum filling_state
 185 {
 186     STATE_IDLE = 0, /* audio is stopped: nothing to do */
 187     STATE_FILLING,  /* adding tracks to the buffer */
 188     STATE_FULL,     /* can't add any more tracks */
 189     STATE_END_OF_PLAYLIST, /* all remaining tracks have been added */
 190     STATE_FINISHED, /* all remaining tracks are fully buffered */
 191     STATE_ENDING,   /* audio playback is ending */
 192     STATE_ENDED,    /* audio playback is done */
 193     STATE_USB,      /* USB mode, ignore most messages */
 194 } filling = STATE_IDLE;
 195
 196 /* Track info - holds information about each track in the buffer */
 197 struct track_info
 198 {
 199     /* In per-track allocated order: */
 200     int id3_hid;                /* Metadata handle ID */
 201     int cuesheet_hid;           /* Parsed cuesheet handle ID */
 202 #ifdef HAVE_ALBUMART
 203     int aa_hid[MAX_MULTIPLE_AA];/* Album art handle IDs */
 204 #endif
 205 #ifdef HAVE_CODEC_BUFFERING
 206     int codec_hid;              /* Buffered codec handle ID */
 207 #endif
 208     int audio_hid;              /* Main audio data handle ID */
 209     size_t filesize;            /* File total length on disk
 210                                    TODO: This should be stored
 211                                          in the handle or the
 212                                          id3 and would use less
 213                                          ram */
 214 };
 215
 216 /* Track list - holds info about all buffered tracks */
 217 #if MEMORYSIZE >= 32
 218 #define TRACK_LIST_LEN  128 /* Must be 2^int(+n) */
 219 #elif MEMORYSIZE >= 16
 220 #define TRACK_LIST_LEN   64
 221 #elif MEMORYSIZE >= 8
 222 #define TRACK_LIST_LEN   32
 223 #else
 224 #define TRACK_LIST_LEN   16
 225 #endif
 226
 227 #define TRACK_LIST_MASK (TRACK_LIST_LEN-1)
 228
 229 static struct
 230 {
 231     /* read, write and current are maintained unwrapped, limited only by the
 232        unsigned int range and wrap-safe comparisons are used */
 233
 234     /* NOTE: there appears to be a bug in arm-elf-eabi-gcc 4.4.4 for ARMv4 where
 235        if 'end' follows 'start' in this structure, track_list_count performs
 236        'start - end' rather than 'end - start', giving negative count values...
 237        so leave it this way for now! */
 238     unsigned int end;           /* Next open position */
 239     unsigned int start;         /* First track in list */
 240     unsigned int current;       /* Currently decoding track */
 241     struct track_info tracks[TRACK_LIST_LEN]; /* Buffered track information */
 242 } track_list; /* (A, O-) */
 243
 244
 245 /* Playlist steps from playlist position to next track to be buffered */
 246 static int playlist_peek_offset = 0;
 247
 248 /* Metadata handle of track load in progress (meaning all handles have not
 249    yet been opened for the track, id3 always exists or the track does not)
 250
 251    Tracks are keyed by their metadata handles if track list pointers are
 252    insufficient to make comparisons */
 253 static int in_progress_id3_hid = ERR_HANDLE_NOT_FOUND;
 254
 255 #ifdef HAVE_DISK_STORAGE
 256 /* Buffer margin A.K.A. anti-skip buffer (in seconds) */
 257 static size_t buffer_margin = 5;
 258 #endif
 259
 260 /* Values returned for track loading */
 261 enum track_load_status
 262 {
 263     LOAD_TRACK_ERR_START_CODEC   = -6,
 264     LOAD_TRACK_ERR_FINISH_FAILED = -5,
 265     LOAD_TRACK_ERR_FINISH_FULL   = -4,
 266     LOAD_TRACK_ERR_BUSY          = -3,
 267     LOAD_TRACK_ERR_NO_MORE       = -2,
 268     LOAD_TRACK_ERR_FAILED        = -1,
 269     LOAD_TRACK_OK                =  0,
 270     LOAD_TRACK_READY             =  1,
 271 };
 272
 273 /** Track change controls **/
 274
 275 /* What sort of skip is pending globally? */
 276 enum track_skip_type
 277 {
 278     /* Relative to what user is intended to see: */
 279     /* Codec: +0, Track List: +0, Playlist: +0 */
 280     TRACK_SKIP_NONE = 0,          /* no track skip */
 281     /* Codec: +1, Track List: +1, Playlist: +0 */
 282     TRACK_SKIP_AUTO,              /* codec-initiated skip */
 283     /* Codec: +1, Track List: +1, Playlist: +1 */
 284     TRACK_SKIP_AUTO_NEW_PLAYLIST, /* codec-initiated skip is new playlist */
 285     /* Codec: xx, Track List: +0, Playlist: +0 */
 286     TRACK_SKIP_AUTO_END_PLAYLIST, /* codec-initiated end of playlist */
 287     /* Manual skip: Never pends */
 288     TRACK_SKIP_MANUAL,            /* manual track skip */
 289     /* Manual skip: Never pends */
 290     TRACK_SKIP_DIR_CHANGE,        /* manual directory skip */
 291 } skip_pending = TRACK_SKIP_NONE;
 292
 293 /* Note about TRACK_SKIP_AUTO_NEW_PLAYLIST:
 294    Fixing playlist code to be able to peek into the first song of
 295    the next playlist would fix any issues and this wouldn't need
 296    to be a special case since pre-advancing the playlist would be
 297    unneeded - it could be much more like TRACK_SKIP_AUTO and all
 298    actions that require reversal during an in-progress transition
 299    would work as expected */
 300
 301 /* Used to indicate status for the events. Must be separate to satisfy all
 302    clients so the correct metadata is read when sending the change events
 303    and also so that it is read correctly outside the events. */
 304 static bool automatic_skip = false; /* (A, O-) */
 305
 306 /* Pending manual track skip offset */
 307 static int skip_offset = 0; /* (A, O) */
 308
 309 /* Track change notification */
 310 static struct
 311 {
 312     unsigned int in;  /* Number of pcmbuf posts (audio isr) */
 313     unsigned int out; /* Number of times audio has read the difference */
 314 } track_change = { 0, 0 };
 315
 316 /** Codec status **/
 317 /* Did the codec notify us it finished while we were paused or while still
 318    in an automatic transition?
 319
 320    If paused, it is necessary to defer a codec-initiated skip until resuming
 321    or else the track will move forward while not playing audio!
 322
 323    If in-progress, skips should not build-up ahead of where the WPS is when
 324    really short tracks finish decoding.
 325
 326    If it is forgotten, it will be missed altogether and playback will just sit
 327    there looking stupid and comatose until the user does something */
 328 static bool codec_skip_pending = false;
 329 static int  codec_skip_status;
 330 static bool codec_seeking = false;          /* Codec seeking ack expected? */
 331 static unsigned int position_key = 0;
 332
 333 /* Event queues */
 334 static struct event_queue audio_queue SHAREDBSS_ATTR;
 335
 336 /* Audio thread */
 337 static struct queue_sender_list audio_queue_sender_list SHAREDBSS_ATTR;
 338 static long audio_stack[(DEFAULT_STACK_SIZE + 0x1000)/sizeof(long)];
 339 static const char audio_thread_name[] = "audio";
 340 static unsigned int audio_thread_id = 0;
 341
 342 /* Forward declarations */
 343 enum audio_start_playback_flags
 344 {
 345     AUDIO_START_RESTART = 0x1, /* "Restart" playback (flush _all_ tracks) */
 346     AUDIO_START_NEWBUF  = 0x2, /* Mark the audiobuffer as invalid */
 347 };
 348
 349 static void audio_start_playback(size_t offset, unsigned int flags);
 350 static void audio_stop_playback(void);
 351 static void buffer_event_buffer_low_callback(void *data);
 352 static void buffer_event_rebuffer_callback(void *data);
 353 static void buffer_event_finished_callback(void *data);
 354 void audio_pcmbuf_sync_position(void);
 355
 356
 357 /**************************************/
 358
 359 /** --- audio_queue helpers --- **/
 360 static void audio_queue_post(long id, intptr_t data)
 361 {
 362     queue_post(&audio_queue, id, data);
 363 }
 364
 365 static intptr_t audio_queue_send(long id, intptr_t data)
 366 {
 367     return queue_send(&audio_queue, id, data);
 368 }
 369
 370
 371 /** --- MP3Entry --- **/
 372
 373 /* Does the mp3entry have enough info for us to use it? */
 374 static struct mp3entry * valid_mp3entry(const struct mp3entry *id3)
 375 {
 376     return id3 && (id3->length != 0 || id3->filesize != 0) &&
 377            id3->codectype != AFMT_UNKNOWN ? (struct mp3entry *)id3 : NULL;
 378 }
 379
 380 /* Return a pointer to an mp3entry on the buffer, as it is */
 381 static struct mp3entry * bufgetid3(int handle_id)
 382 {
 383     if (handle_id < 0)
 384         return NULL;
 385
 386     struct mp3entry *id3;
 387     ssize_t ret = bufgetdata(handle_id, 0, (void *)&id3);
 388
 389     if (ret != sizeof(struct mp3entry))
 390         return NULL;
 391
 392     return id3;
 393 }
 394
 395 /* Read an mp3entry from the buffer, adjusted */
 396 static bool bufreadid3(int handle_id, struct mp3entry *id3out)
 397 {
 398     struct mp3entry *id3 = bufgetid3(handle_id);
 399
 400     if (id3)
 401     {
 402         copy_mp3entry(id3out, id3);
 403         return true;
 404     }
 405
 406     return false;
 407 }
 408
 409 /* Lock the id3 mutex */
 410 static void id3_mutex_lock(void)
 411 {
 412     mutex_lock(&id3_mutex);
 413 }
 414
 415 /* Unlock the id3 mutex */
 416 static void id3_mutex_unlock(void)
 417 {
 418     mutex_unlock(&id3_mutex);
 419 }
 420
 421 /* Return one of the collection of mp3entry pointers - collect them all here */
 422 static inline struct mp3entry * id3_get(enum audio_id3_types id3_num)
 423 {
 424     switch (id3_num)
 425     {
 426     case UNBUFFERED_ID3:
 427         return &audio_scratch_memory->unbuffered_id3;
 428     case CODEC_ID3:
 429         return &audio_scratch_memory->codec_id3;
 430     default:
 431         return &static_id3_entries[id3_num];
 432     }
 433 }
 434
 435 /* Copy an mp3entry into one of the mp3 entries */
 436 static void id3_write(enum audio_id3_types id3_num,
 437                       const struct mp3entry *id3_src)
 438 {
 439     struct mp3entry *dest_id3 = id3_get(id3_num);
 440
 441     if (id3_src)
 442         copy_mp3entry(dest_id3, id3_src);
 443     else
 444         wipe_mp3entry(dest_id3);
 445 }
 446
 447 /* Call id3_write "safely" because peek aheads can yield, even if the fast
 448    preview isn't enabled */
 449 static void id3_write_locked(enum audio_id3_types id3_num,
 450                              const struct mp3entry *id3_src)
 451 {
 452     id3_mutex_lock();
 453     id3_write(id3_num, id3_src);
 454     id3_mutex_unlock();
 455 }
 456
 457
 458 /** --- Track info --- **/
 459
 460 /* Close a handle and mark it invalid */
 461 static void track_info_close_handle(int *hid_p)
 462 {
 463     int hid = *hid_p;
 464
 465     /* bufclose returns true if the handle is not found, or if it is closed
 466      * successfully, so these checks are safe on non-existant handles */
 467     if (hid >= 0)
 468         bufclose(hid);
 469
 470     /* Always reset to "no handle" in case it was something else */
 471     *hid_p = ERR_HANDLE_NOT_FOUND;
 472 }
 473
 474 /* Close all handles in a struct track_info and clear it */
 475 static void track_info_close(struct track_info *info)
 476 {
 477     /* Close them in the order they are allocated on the buffer to speed up
 478        the handle searching */
 479     track_info_close_handle(&info->id3_hid);
 480     track_info_close_handle(&info->cuesheet_hid);
 481 #ifdef HAVE_ALBUMART
 482     int i;
 483     FOREACH_ALBUMART(i)
 484         track_info_close_handle(&info->aa_hid[i]);
 485 #endif
 486 #ifdef HAVE_CODEC_BUFFERING
 487     track_info_close_handle(&info->codec_hid);
 488 #endif
 489     track_info_close_handle(&info->audio_hid);
 490     info->filesize = 0;
 491 }
 492
 493 /* Invalidate all members to initial values - does not close handles */
 494 static void track_info_wipe(struct track_info * info)
 495 {
 496     info->id3_hid = ERR_HANDLE_NOT_FOUND;
 497     info->cuesheet_hid = ERR_HANDLE_NOT_FOUND;
 498 #ifdef HAVE_ALBUMART
 499     int i;
 500     FOREACH_ALBUMART(i)
 501         info->aa_hid[i] = ERR_HANDLE_NOT_FOUND;
 502 #endif
 503 #ifdef HAVE_CODEC_BUFFERING
 504     info->codec_hid = ERR_HANDLE_NOT_FOUND;
 505 #endif
 506     info->audio_hid = ERR_HANDLE_NOT_FOUND;
 507     info->filesize = 0;
 508 }
 509
 510
 511 /** --- Track list --- **/
 512
 513 /* Initialize the track list */
 514 static void track_list_init(void)
 515 {
 516     int i;
 517     for (i = 0; i < TRACK_LIST_LEN; i++)
 518         track_info_wipe(&track_list.tracks[i]);
 519
 520     track_list.start = track_list.end = track_list.current;
 521 }
 522
 523 /* Return number of items allocated in the list */
 524 static unsigned int track_list_count(void)
 525 {
 526     return track_list.end - track_list.start;
 527 }
 528
 529 /* Return true if the list is empty */
 530 static inline bool track_list_empty(void)
 531 {
 532     return track_list.end == track_list.start;
 533 }
 534
 535 /* Returns true if the list is holding the maximum number of items */
 536 static bool track_list_full(void)
 537 {
 538     return track_list.end - track_list.start >= TRACK_LIST_LEN;
 539 }
 540
 541 /* Test if the index is within the allocated range */
 542 static bool track_list_in_range(int pos)
 543 {
 544     return (int)(pos - track_list.start) >= 0 &&
 545            (int)(pos - track_list.end) < 0;
 546 }
 547
 548 static struct track_info * track_list_entry(int pos)
 549 {
 550     return &track_list.tracks[pos & TRACK_LIST_MASK];
 551 }
 552
 553 /* Return the info of the last allocation plus an offset, NULL if result is
 554    out of bounds */
 555 static struct track_info * track_list_last(int offset)
 556 {
 557     /* Last is before the end since the end isn't inclusive */
 558     unsigned int pos = track_list.end + offset - 1;
 559
 560     if (!track_list_in_range(pos))
 561         return NULL;
 562
 563     return track_list_entry(pos);
 564 }
 565
 566 /* Allocate space at the end for another track if not full */
 567 static struct track_info * track_list_alloc_track(void)
 568 {
 569     if (track_list_full())
 570         return NULL;
 571
 572     return track_list_entry(track_list.end++);
 573 }
 574
 575 /* Remove the last track entry allocated in order to support backing out
 576    of a track load */
 577 static void track_list_unalloc_track(void)
 578 {
 579     if (track_list_empty())
 580         return;
 581
 582     track_list.end--;
 583
 584     if (track_list.current == track_list.end &&
 585         track_list.current != track_list.start)
 586     {
 587         /* Current _must_ remain within bounds */
 588         track_list.current--;
 589     }
 590 }
 591
 592 /* Return current track plus an offset, NULL if result is out of bounds */
 593 static struct track_info * track_list_current(int offset)
 594 {
 595     unsigned int pos = track_list.current + offset;
 596
 597     if (!track_list_in_range(pos))
 598         return NULL;
 599
 600     return track_list_entry(pos);
 601 }
 602
 603 /* Return current based upon what's intended that the user sees - not
 604    necessarily where decoding is taking place */
 605 static struct track_info * track_list_user_current(int offset)
 606 {
 607     if (skip_pending == TRACK_SKIP_AUTO ||
 608         skip_pending == TRACK_SKIP_AUTO_NEW_PLAYLIST)
 609     {
 610         offset--;
 611     }
 612
 613     return track_list_current(offset);
 614 }
 615
 616 /* Advance current track by an offset, return false if result is out of
 617    bounds */
 618 static struct track_info * track_list_advance_current(int offset)
 619 {
 620     unsigned int pos = track_list.current + offset;
 621
 622     if (!track_list_in_range(pos))
 623         return NULL;
 624
 625     track_list.current = pos;
 626     return track_list_entry(pos);
 627 }
 628
 629 /* Clear tracks in the list, optionally preserving the current track -
 630    returns 'false' if the operation was changed */
 631 enum track_clear_action
 632 {
 633     TRACK_LIST_CLEAR_ALL = 0, /* Clear all tracks */
 634     TRACK_LIST_KEEP_CURRENT,  /* Keep current only; clear before + after */
 635     TRACK_LIST_KEEP_NEW       /* Keep current and those that follow */
 636 };
 637
 638 static void track_list_clear(enum track_clear_action action)
 639 {
 640     logf("%s(%d)", __func__, (int)action);
 641
 642     /* Don't care now since rebuffering is imminent */
 643     buf_set_watermark(0);
 644
 645     if (action != TRACK_LIST_CLEAR_ALL)
 646     {
 647         struct track_info *cur = track_list_current(0);
 648
 649         if (!cur || cur->id3_hid < 0)
 650             action = TRACK_LIST_CLEAR_ALL; /* Nothing worthwhile keeping */
 651     }
 652
 653     /* Noone should see this progressing */
 654     int start = track_list.start;
 655     int current = track_list.current;
 656     int end = track_list.end;
 657
 658     track_list.start = current;
 659
 660     switch (action)
 661     {
 662     case TRACK_LIST_CLEAR_ALL:
 663         /* Result: .start = .current, .end = .current */
 664         track_list.end = current;
 665         break;
 666
 667     case TRACK_LIST_KEEP_CURRENT:
 668         /* Result: .start = .current, .end = .current + 1 */
 669         track_list.end = current + 1;
 670         break;
 671
 672     case TRACK_LIST_KEEP_NEW:
 673         /* Result: .start = .current, .end = .end */
 674         end = current;
 675         break;
 676     }
 677
 678     /* Close all open handles in the range except the for the current track
 679        if preserving that */
 680     while (start != end)
 681     {
 682         if (action != TRACK_LIST_KEEP_CURRENT || start != current)
 683         {
 684             struct track_info *info =
 685                 &track_list.tracks[start & TRACK_LIST_MASK];
 686
 687             /* If this is the in-progress load, abort it */
 688             if (in_progress_id3_hid >= 0 &&
 689                 info->id3_hid == in_progress_id3_hid)
 690             {
 691                 in_progress_id3_hid = ERR_HANDLE_NOT_FOUND;
 692             }
 693
 694             track_info_close(info);
 695         }
 696
 697         start++;
 698     }
 699 }
 700
 701
 702 /** --- Audio buffer -- **/
 703
 704 /* What size is needed for the scratch buffer? */
 705 static size_t scratch_mem_size(void)
 706 {
 707     size_t size = sizeof (struct audio_scratch_memory);
 708
 709     if (global_settings.cuesheet)
 710         size += sizeof (struct cuesheet);
 711
 712     return size;
 713 }
 714
 715 /* Initialize the memory area where data is stored that is only used when
 716    playing audio and anything depending upon it */
 717 static void scratch_mem_init(void *mem)
 718 {
 719     audio_scratch_memory = (struct audio_scratch_memory *)mem;
 720     id3_write_locked(UNBUFFERED_ID3, NULL);
 721     id3_write(CODEC_ID3, NULL);
 722     ci.id3 = id3_get(CODEC_ID3);
 723     audio_scratch_memory->curr_cue = NULL;
 724
 725     if (global_settings.cuesheet)
 726     {
 727         audio_scratch_memory->curr_cue =
 728             SKIPBYTES((struct cuesheet *)audio_scratch_memory,
 729                       sizeof (struct audio_scratch_memory));
 730     }
 731 }
 732
 733 static int audiobuf_handle;
 734 #define AUDIO_BUFFER_RESERVE (256*1024)
 735 static size_t filebuflen;
 736
 737
 738 size_t audio_buffer_size(void)
 739 {
 740     if (audiobuf_handle > 0)
 741         return filebuflen - AUDIO_BUFFER_RESERVE;
 742     return 0;
 743 }
 744
 745 size_t audio_buffer_available(void)
 746 {
 747     size_t size = 0;
 748     size_t core_size = core_available();
 749     if (audiobuf_handle > 0) /* if allocated return what we can give */
 750         size = filebuflen - AUDIO_BUFFER_RESERVE - 128;
 751     return MAX(core_size, size);
 752 }
 753
 754 /* Set up the audio buffer for playback
 755  * filebuflen must be pre-initialized with the maximum size */
 756 static void audio_reset_buffer_noalloc(
 757     void *filebuf, enum audio_buffer_state state)
 758 {
 759     /*
 760      * Layout audio buffer as follows:
 761      * [[|TALK]|SCRATCH|BUFFERING|PCM]
 762      */
 763
 764     /* see audio_get_recording_buffer if this is modified */
 765     logf("%s()", __func__);
 766
 767     /* If the setup of anything allocated before the file buffer is
 768        changed, do check the adjustments after the buffer_alloc call
 769        as it will likely be affected and need sliding over */
 770
 771     /* Initially set up file buffer as all space available */
 772     size_t allocsize;
 773
 774     /* Subtract whatever voice needs (we're called when promoting
 775                                       the state only) */
 776     allocsize = talkbuf_init(filebuf);
 777     allocsize = ALIGN_UP(allocsize, sizeof (intptr_t));
 778     if (allocsize > filebuflen)
 779         goto bufpanic;
 780
 781     filebuf += allocsize;
 782     filebuflen -= allocsize;
 783
 784     if (state == AUDIOBUF_STATE_INITIALIZED)
 785     {
 786         /* Subtract whatever the pcm buffer says it used plus the guard
 787            buffer */
 788         allocsize = pcmbuf_init(filebuf + filebuflen);
 789
 790         /* Make sure filebuflen is a pointer sized multiple after
 791            adjustment */
 792         allocsize = ALIGN_UP(allocsize, sizeof (intptr_t));
 793         if (allocsize > filebuflen)
 794             goto bufpanic;
 795
 796         filebuflen -= allocsize;
 797
 798         /* Scratch memory */
 799         allocsize = scratch_mem_size();
 800         if (allocsize > filebuflen)
 801             goto bufpanic;
 802
 803         scratch_mem_init(filebuf);
 804         filebuf += allocsize;
 805         filebuflen -= allocsize;
 806
 807         buffering_reset(filebuf, filebuflen);
 808     }
 809
 810     buffer_state = state;
 811
 812 #if defined(ROCKBOX_HAS_LOGF) && defined(LOGF_ENABLE)
 813     /* Make sure everything adds up - yes, some info is a bit redundant but
 814        aids viewing and the summation of certain variables should add up to
 815        the location of others. */
 816     {
 817         logf("fbuf:   %08X", (unsigned)filebuf);
 818         logf("fbufe:  %08X", (unsigned)(filebuf + filebuflen));
 819         logf("sbuf:   %08X", (unsigned)audio_scratch_memory);
 820         logf("sbufe:  %08X", (unsigned)(audio_scratch_memory + allocsize));
 821     }
 822 #endif
 823
 824     return;
 825
 826 bufpanic:
 827     panicf("%s(): EOM (%zu > %zu)", __func__, allocsize, filebuflen);
 828 }
 829
 830 /* Buffer must not move. */
 831 static int shrink_callback(int handle, unsigned hints, void* start, size_t old_size)
 832 {
 833     struct queue_event ev;
 834     static const long filter_list[][2] =
 835     {
 836         /* codec messages */
 837         { Q_AUDIO_PLAY, Q_AUDIO_PLAY },
 838     };
 839     /* filebuflen is, at this point, the buffering.c buffer size,
 840      * i.e. the audiobuf except voice, scratch mem, pcm, ... */
 841     ssize_t extradata_size = old_size - filebuflen;
 842     /* check what buflib requests */
 843     size_t wanted_size = (hints & BUFLIB_SHRINK_SIZE_MASK);
 844     ssize_t size = (ssize_t)old_size - wanted_size;
 845     /* keep at least 256K for the buffering */
 846     if ((size - extradata_size) < AUDIO_BUFFER_RESERVE)
 847         return BUFLIB_CB_CANNOT_SHRINK;
 848
 849
 850     /* TODO: Do it without stopping playback, if possible */
 851     long offset = audio_current_track()->offset;
 852     /* resume if playing */
 853     bool playing = (audio_status() == AUDIO_STATUS_PLAY);
 854     /* There's one problem with stoping and resuming: If it happens in a too
 855      * frequent fashion, the codecs lose the resume postion and playback
 856      * begins from the beginning.
 857      * To work around use queue_post() to effectively delay the resume in case
 858      * we're called another time. However this has another problem: id3->offset
 859      * gets zero since playback is stopped. Therefore, try to peek at the
 860      * queue_post from the last call to get the correct offset. This also
 861      * lets us conviniently remove the queue event so Q_AUDIO_PLAY is only
 862      * processed once. */
 863     bool play_queued = queue_peek_ex(&audio_queue, &ev, QPEEK_REMOVE_EVENTS, filter_list);
 864
 865     if (playing && offset > 0) /* current id3->offset is king */
 866         ev.data = offset;
 867
 868     /* don't call audio_hard_stop() as it frees this handle */
 869     if (thread_self() == audio_thread_id)
 870     {   /* inline case Q_AUDIO_STOP (audio_hard_stop() response
 871          * if we're in the audio thread */
 872         audio_stop_playback();
 873         queue_clear(&audio_queue);
 874     }
 875     else
 876         audio_queue_send(Q_AUDIO_STOP, 1);
 877 #ifdef PLAYBACK_VOICE
 878     voice_stop();
 879 #endif
 880     /* we should be free to change the buffer now
 881      * set final buffer size before calling audio_reset_buffer_noalloc()
 882      * (now it's the total size, the call will subtract voice etc) */
 883     filebuflen = size;
 884     switch (hints & BUFLIB_SHRINK_POS_MASK)
 885     {
 886         case BUFLIB_SHRINK_POS_BACK:
 887             core_shrink(handle, start, size);
 888             audio_reset_buffer_noalloc(start, buffer_state);
 889             break;
 890         case BUFLIB_SHRINK_POS_FRONT:
 891             core_shrink(handle, start + wanted_size, size);
 892             audio_reset_buffer_noalloc(start + wanted_size,
 893                                        buffer_state);
 894             break;
 895     }
 896     if (playing || play_queued)
 897     {
 898         /* post, to make subsequent calls not break the resume position */
 899         audio_queue_post(Q_AUDIO_PLAY, ev.data);
 900     }
 901
 902     return BUFLIB_CB_OK;
 903 }
 904
 905 static struct buflib_callbacks ops = {
 906     .move_callback = NULL,
 907     .shrink_callback = shrink_callback,
 908 };
 909
 910 static void audio_reset_buffer(enum audio_buffer_state state)
 911 {
 912     if (audiobuf_handle > 0)
 913     {
 914         core_free(audiobuf_handle);
 915         audiobuf_handle = 0;
 916     }
 917     audiobuf_handle = core_alloc_maximum("audiobuf", &filebuflen, &ops);
 918     unsigned char *filebuf = core_get_data(audiobuf_handle);
 919
 920     audio_reset_buffer_noalloc(filebuf, state);
 921 }
 922
 923 /* Set the buffer margin to begin rebuffering when 'seconds' from empty */
 924 static void audio_update_filebuf_watermark(int seconds)
 925 {
 926     size_t bytes = 0;
 927
 928 #ifdef HAVE_DISK_STORAGE
 929     int spinup = ata_spinup_time();
 930
 931     if (seconds == 0)
 932     {
 933         /* By current setting */
 934         seconds = buffer_margin;
 935     }
 936     else
 937     {
 938         /* New setting */
 939         buffer_margin = seconds;
 940
 941         if (buf_get_watermark() == 0)
 942         {
 943             /* Write a watermark only if the audio thread already did so for
 944                itself or it will fail to set the event and the watermark - if
 945                it hasn't yet, it will use the new setting when it does */
 946             return;
 947         }
 948     }
 949
 950     if (spinup)
 951         seconds += (spinup / HZ) + 1;
 952     else
 953         seconds += 5;
 954
 955     seconds += buffer_margin;
 956 #else
 957     /* flash storage */
 958     seconds = 1;
 959 #endif
 960
 961     /* Watermark is a function of the bitrate of the last track in the buffer */
 962     struct mp3entry *id3 = NULL;
 963     struct track_info *info = track_list_last(0);
 964
 965     if (info)
 966         id3 = valid_mp3entry(bufgetid3(info->id3_hid));
 967
 968     if (id3)
 969     {
 970         if (!rbcodec_format_is_atomic(id3->codectype))
 971         {
 972             bytes = id3->bitrate * (1000/8) * seconds;
 973         }
 974         else
 975         {
 976             /* Bitrate has no meaning to buffering margin for atomic audio -
 977                rebuffer when it's the only track left unless it's the only
 978                track that fits, in which case we should avoid constant buffer
 979                low events */
 980             if (track_list_count() > 1)
 981                 bytes = info->filesize + 1;
 982         }
 983     }
 984     else
 985     {
 986         /* Then set the minimum - this should not occur anyway */
 987         logf("fwmark: No id3 for last track (s%u/c%u/e%u)",
 988              track_list.start, track_list.current, track_list.end);
 989     }
 990
 991     /* Actually setting zero disables the notification and we use that
 992        to detect that it has been reset */
 993     buf_set_watermark(MAX(bytes, 1));
 994     logf("fwmark: %lu", (unsigned long)bytes);
 995 }
 996
 997
 998 /** -- Track change notification -- **/
 999
1000 /* Check the pcmbuf track changes and return write the message into the event
1001    if there are any */
1002 static inline bool audio_pcmbuf_track_change_scan(void)
1003 {
1004     if (track_change.out != track_change.in)
1005     {
1006         track_change.out++;
1007         return true;
1008     }
1009
1010     return false;
1011 }
1012
1013 /* Clear outstanding track change posts */
1014 static inline void audio_pcmbuf_track_change_clear(void)
1015 {
1016     track_change.out = track_change.in;
1017 }
1018
1019 /* Post a track change notification - called by audio ISR */
1020 static inline void audio_pcmbuf_track_change_post(void)
1021 {
1022     track_change.in++;
1023 }
1024
1025
1026 /** --- Helper functions --- **/
1027
1028 /* Removes messages that might end up in the queue before or while processing
1029    a manual track change. Responding to them would be harmful since they
1030    belong to a previous track's playback period. Anything that would generate
1031    the stale messages must first be put into a state where it will not do so.
1032  */
1033 static void audio_clear_track_notifications(void)
1034 {
1035     static const long filter_list[][2] =
1036     {
1037         /* codec messages */
1038         { Q_AUDIO_CODEC_SEEK_COMPLETE, Q_AUDIO_CODEC_COMPLETE },
1039         /* track change messages */
1040         { Q_AUDIO_TRACK_CHANGED, Q_AUDIO_TRACK_CHANGED },
1041     };
1042
1043     const int filter_count = ARRAYLEN(filter_list) - 1;
1044
1045     /* Remove any pcmbuf notifications */
1046     pcmbuf_monitor_track_change(false);
1047     audio_pcmbuf_track_change_clear();
1048
1049     /* Scrub the audio queue of the old mold */
1050     while (queue_peek_ex(&audio_queue, NULL,
1051                          filter_count | QPEEK_REMOVE_EVENTS,
1052                          filter_list))
1053     {
1054         yield(); /* Not strictly needed, per se, ad infinitum, ra, ra */
1055     }
1056 }
1057
1058 /* Takes actions based upon track load status codes */
1059 static void audio_handle_track_load_status(int trackstat)
1060 {
1061     switch (trackstat)
1062     {
1063     case LOAD_TRACK_ERR_NO_MORE:
1064         if (track_list_count() > 0)
1065             break;
1066
1067     case LOAD_TRACK_ERR_START_CODEC:
1068         audio_queue_post(Q_AUDIO_CODEC_COMPLETE, CODEC_ERROR);
1069         break;
1070
1071     default:
1072         break;
1073     }
1074 }
1075
1076 /* Announce the end of playing the current track */
1077 static void audio_playlist_track_finish(void)
1078 {
1079     struct mp3entry *ply_id3 = id3_get(PLAYING_ID3);
1080     struct mp3entry *id3 = valid_mp3entry(ply_id3);
1081
1082     playlist_update_resume_info(filling == STATE_ENDED ? NULL : id3);
1083
1084     if (id3)
1085     {
1086         send_event(PLAYBACK_EVENT_TRACK_FINISH, id3);
1087         prev_track_elapsed = id3->elapsed;
1088     }
1089     else
1090     {
1091         prev_track_elapsed = 0;
1092     }
1093 }
1094
1095 /* Announce the beginning of the new track */
1096 static void audio_playlist_track_change(void)
1097 {
1098     struct mp3entry *id3 = valid_mp3entry(id3_get(PLAYING_ID3));
1099
1100     if (id3)
1101         send_event(PLAYBACK_EVENT_TRACK_CHANGE, id3);
1102
1103     position_key = pcmbuf_get_position_key();
1104
1105     playlist_update_resume_info(id3);
1106 }
1107
1108 /* Change the data for the next track and send the event */
1109 static void audio_update_and_announce_next_track(const struct mp3entry *id3_next)
1110 {
1111     id3_write_locked(NEXTTRACK_ID3, id3_next);
1112     send_event(PLAYBACK_EVENT_NEXTTRACKID3_AVAILABLE,
1113                id3_get(NEXTTRACK_ID3));
1114 }
1115
1116 /* Bring the user current mp3entry up to date and set a new offset for the
1117    buffered metadata */
1118 static void playing_id3_sync(struct track_info *user_info, off_t offset)
1119 {
1120     id3_mutex_lock();
1121
1122     struct mp3entry *id3 = bufgetid3(user_info->id3_hid);
1123     struct mp3entry *playing_id3 = id3_get(PLAYING_ID3);
1124
1125     pcm_play_lock();
1126
1127     unsigned long e = playing_id3->elapsed;
1128     unsigned long o = playing_id3->offset;
1129
1130     id3_write(PLAYING_ID3, id3);
1131
1132     if (offset < 0)
1133     {
1134         playing_id3->elapsed = e;
1135         playing_id3->offset = o;
1136         offset = 0;
1137     }
1138
1139     pcm_play_unlock();
1140
1141     if (id3)
1142         id3->offset = offset;
1143
1144     id3_mutex_unlock();
1145 }
1146
1147 /* Wipe-out track metadata - current is optional */
1148 static void wipe_track_metadata(bool current)
1149 {
1150     id3_mutex_lock();
1151
1152     if (current)
1153         id3_write(PLAYING_ID3, NULL);
1154
1155     id3_write(NEXTTRACK_ID3, NULL);
1156     id3_write(UNBUFFERED_ID3, NULL);
1157
1158     id3_mutex_unlock();
1159 }
1160
1161 /* Called when buffering is completed on the last track handle */
1162 static void filling_is_finished(void)
1163 {
1164     logf("last track finished buffering");
1165
1166     /* There's no more to load or watch for */
1167     buf_set_watermark(0);
1168     filling = STATE_FINISHED;
1169 }
1170
1171 /* Stop the codec decoding or waiting for its data to be ready - returns
1172    'false' if the codec ended up stopped */
1173 static bool halt_decoding_track(bool stop)
1174 {
1175     /* If it was waiting for us to clear the buffer to make a rebuffer
1176        happen, it should cease otherwise codec_stop could deadlock waiting
1177        for the codec to go to its main loop - codec's request will now
1178        force-fail */
1179     bool retval = false;
1180
1181     buf_signal_handle(ci.audio_hid, true);
1182
1183     if (stop)
1184         codec_stop();
1185     else
1186         retval = codec_pause();
1187
1188     audio_clear_track_notifications();
1189
1190     /* We now know it's idle and not waiting for buffered data */
1191     buf_signal_handle(ci.audio_hid, false);
1192
1193     codec_skip_pending = false;
1194     codec_seeking = false;
1195
1196     return retval;
1197 }
1198
1199 /* Wait for any in-progress fade to complete */
1200 static void audio_wait_fade_complete(void)
1201 {
1202     /* Just loop until it's done */
1203     while (pcmbuf_fading())
1204         sleep(0);
1205 }
1206
1207 /* End the ff/rw mode */
1208 static void audio_ff_rewind_end(void)
1209 {
1210     /* A seamless seek (not calling audio_pre_ff_rewind) skips this
1211        section */
1212     if (ff_rw_mode)
1213     {
1214         ff_rw_mode = false;
1215
1216         if (codec_seeking)
1217         {
1218             /* Clear the buffer */
1219             pcmbuf_play_stop();
1220             audio_pcmbuf_sync_position();
1221         }
1222
1223         if (play_status != PLAY_PAUSED)
1224         {
1225             /* Seeking-while-playing, resume PCM playback */
1226             pcmbuf_pause(false);
1227         }
1228     }
1229 }
1230
1231 /* Complete the codec seek */
1232 static void audio_complete_codec_seek(void)
1233 {
1234     /* If a seek completed while paused, 'paused' is true.
1235      * If seeking from seek mode, 'ff_rw_mode' is true. */
1236     if (codec_seeking)
1237     {
1238         audio_ff_rewind_end();
1239         codec_seeking = false; /* set _after_ the call! */
1240     }
1241     /* else it's waiting and we must repond */
1242 }
1243
1244 /* Get the current cuesheet pointer */
1245 static inline struct cuesheet * get_current_cuesheet(void)
1246 {
1247     return audio_scratch_memory->curr_cue;
1248 }
1249
1250 /* Read the cuesheet from the buffer */
1251 static void buf_read_cuesheet(int handle_id)
1252 {
1253     struct cuesheet *cue = get_current_cuesheet();
1254
1255     if (!cue || handle_id < 0)
1256         return;
1257
1258     bufread(handle_id, sizeof (struct cuesheet), cue);
1259 }
1260
1261 /* Backend to peek/current/next track metadata interface functions -
1262    fill in the mp3entry with as much information as we may obtain about
1263    the track at the specified offset from the user current track -
1264    returns false if no information exists with us */
1265 static bool audio_get_track_metadata(int offset, struct mp3entry *id3)
1266 {
1267     if (play_status == PLAY_STOPPED)
1268         return false;
1269
1270     if (id3->path[0] != '\0')
1271         return true; /* Already filled */
1272
1273     struct track_info *info = track_list_user_current(offset);
1274
1275     if (!info)
1276     {
1277         struct mp3entry *ub_id3 = id3_get(UNBUFFERED_ID3);
1278
1279         if (offset > 0 && track_list_user_current(offset - 1))
1280         {
1281             /* Try the unbuffered id3 since we're moving forward */
1282             if (ub_id3->path[0] != '\0')
1283             {
1284                 copy_mp3entry(id3, ub_id3);
1285                 return true;
1286             }
1287         }
1288     }
1289     else if (bufreadid3(info->id3_hid, id3))
1290     {
1291         id3->cuesheet = NULL;
1292         return true;
1293     }
1294
1295     /* We didn't find the ID3 metadata, so we fill it with the little info we
1296        have and return that */
1297
1298     char path[MAX_PATH+1];
1299     if (playlist_peek(offset, path, sizeof (path)))
1300     {
1301 #if defined(HAVE_TC_RAMCACHE) && defined(HAVE_DIRCACHE)
1302         /* Try to get it from the database */
1303         if (!tagcache_fill_tags(id3, path))
1304 #endif
1305         {
1306             /* By now, filename is the only source of info */
1307             fill_metadata_from_path(id3, path);
1308         }
1309
1310         return true;
1311     }
1312
1313     wipe_mp3entry(id3);
1314
1315     return false;
1316 }
1317
1318 /* Get a resume rewind adjusted offset from the ID3 */
1319 static unsigned long resume_rewind_adjusted_offset(const struct mp3entry *id3)
1320 {
1321     unsigned long offset = id3->offset;
1322     size_t resume_rewind = global_settings.resume_rewind *
1323                            id3->bitrate * (1000/8);
1324
1325     if (offset < resume_rewind)
1326         offset = 0;
1327     else
1328         offset -= resume_rewind;
1329
1330     return offset;
1331 }
1332
1333 /* Get the codec into ram and initialize it - keep it if it's ready */
1334 static bool audio_init_codec(struct track_info *track_info,
1335                              struct mp3entry *track_id3)
1336 {
1337     int codt_loaded = get_audio_base_codec_type(codec_loaded());
1338     int hid = ERR_HANDLE_NOT_FOUND;
1339
1340     if (codt_loaded != AFMT_UNKNOWN)
1341     {
1342         int codt = get_audio_base_codec_type(track_id3->codectype);
1343
1344         if (codt == codt_loaded)
1345         {
1346             /* Codec is the same base type */
1347             logf("Reusing prev. codec: %d", track_id3->codectype);
1348 #ifdef HAVE_CODEC_BUFFERING
1349             /* Close any buffered codec (we could have skipped directly to a
1350                format transistion that is the same format as the current track
1351                and the buffered one is no longer needed) */
1352             track_info_close_handle(&track_info->codec_hid);
1353 #endif
1354             return true;
1355         }
1356         else
1357         {
1358             /* New codec - first make sure the old one's gone */
1359             logf("Removing prev. codec: %d", codt_loaded);
1360             codec_unload();
1361         }
1362     }
1363
1364     logf("New codec: %d/%d", track_id3->codectype, codec_loaded());
1365
1366 #ifdef HAVE_CODEC_BUFFERING
1367     /* Codec thread will close the handle even if it fails and will load from
1368        storage if hid is not valid or the buffer load fails */
1369     hid = track_info->codec_hid;
1370     track_info->codec_hid = ERR_HANDLE_NOT_FOUND;
1371 #endif
1372
1373     return codec_load(hid, track_id3->codectype);
1374     (void)track_info; /* When codec buffering isn't supported */
1375 }
1376
1377 #ifdef HAVE_TAGCACHE
1378 /* Check settings for whether the file should be autoresumed */
1379 enum { AUTORESUMABLE_UNKNOWN = 0, AUTORESUMABLE_TRUE, AUTORESUMABLE_FALSE };
1380 static bool autoresumable(struct mp3entry *id3)
1381 {
1382     char *endp, *path;
1383     size_t len;
1384     bool is_resumable;
1385
1386     if (id3->autoresumable)             /* result cached? */
1387         return id3->autoresumable == AUTORESUMABLE_TRUE;
1388
1389     is_resumable = false;
1390
1391     if (id3->path)
1392     {
1393         for (path = global_settings.autoresume_paths;
1394              *path;                     /* search terms left? */
1395              path++)
1396         {
1397             if (*path == ':')           /* Skip empty search patterns */
1398                 continue;
1399
1400             /* FIXME: As soon as strcspn or strchrnul are made available in
1401                the core, the following can be made more efficient. */
1402             endp = strchr(path, ':');
1403             if (endp)
1404                 len = endp - path;
1405             else
1406                 len = strlen(path);
1407
1408             /* Note: At this point, len is always > 0 */
1409
1410             if (strncasecmp(id3->path, path, len) == 0)
1411             {
1412                 /* Full directory-name matches only.  Trailing '/' in
1413                    search path OK. */
1414                 if (id3->path[len] == '/' || id3->path[len - 1] == '/')
1415                 {
1416                     is_resumable = true;
1417                     break;
1418                 }
1419             }
1420             path += len - 1;
1421         }
1422     }
1423
1424     /* cache result */
1425     id3->autoresumable =
1426         is_resumable ? AUTORESUMABLE_TRUE : AUTORESUMABLE_FALSE;
1427
1428     logf("autoresumable: %s is%s resumable",
1429          id3->path, is_resumable ? "" : " not");
1430
1431     return is_resumable;
1432 }
1433 #endif  /* HAVE_TAGCACHE */
1434
1435 /* Start the codec for the current track scheduled to be decoded */
1436 static bool audio_start_codec(bool auto_skip)
1437 {
1438     struct track_info *info = track_list_current(0);
1439     struct mp3entry *cur_id3 = valid_mp3entry(bufgetid3(info->id3_hid));
1440
1441     if (!cur_id3)
1442         return false;
1443
1444     buf_pin_handle(info->id3_hid, true);
1445
1446     if (!audio_init_codec(info, cur_id3))
1447     {
1448         buf_pin_handle(info->id3_hid, false);
1449         return false;
1450     }
1451
1452 #ifdef HAVE_TAGCACHE
1453     bool autoresume_enable = global_settings.autoresume_enable;
1454
1455     if (autoresume_enable && !cur_id3->offset)
1456     {
1457         /* Resume all manually selected tracks */
1458         bool resume = !auto_skip;
1459
1460         /* Send the "buffer" event to obtain the resume position for the codec */
1461         send_event(PLAYBACK_EVENT_TRACK_BUFFER, cur_id3);
1462
1463         if (!resume)
1464         {
1465             /* Automatic skip - do further tests to see if we should just
1466                ignore any autoresume position */
1467             int autoresume_automatic = global_settings.autoresume_automatic;
1468
1469             switch (autoresume_automatic)
1470             {
1471             case AUTORESUME_NEXTTRACK_ALWAYS:
1472                 /* Just resume unconditionally */
1473                 resume = true;
1474                 break;
1475             case AUTORESUME_NEXTTRACK_NEVER:
1476                 /* Force-rewind it */
1477                 break;
1478             default:
1479                 /* Not "never resume" - pass resume filter? */
1480                 resume = autoresumable(cur_id3);
1481             }
1482         }
1483
1484         if (!resume)
1485             cur_id3->offset = 0;
1486
1487         logf("%s: Set offset for %s to %lX\n", __func__,
1488              cur_id3->title, cur_id3->offset);
1489     }
1490 #endif /* HAVE_TAGCACHE */
1491
1492     /* Rewind the required amount - if an autoresume was done, this also rewinds
1493        that by the setting's amount
1494
1495        It would be best to have bookkeeping about whether or not the track
1496        sounded or not since skipping to it or else skipping to it while paused
1497        and back again will cause accumulation of silent rewinds - that's not
1498        our job to track directly nor could it be in any reasonable way
1499      */
1500     cur_id3->offset = resume_rewind_adjusted_offset(cur_id3);
1501
1502     /* Update the codec API with the metadata and track info */
1503     id3_write(CODEC_ID3, cur_id3);
1504
1505     ci.audio_hid = info->audio_hid;
1506     ci.filesize = info->filesize;
1507     buf_set_base_handle(info->audio_hid);
1508
1509     /* All required data is now available for the codec */
1510     codec_go();
1511
1512 #ifdef HAVE_TAGCACHE
1513     if (!autoresume_enable || cur_id3->offset)
1514 #endif
1515     {
1516         /* Send the "buffer" event now */
1517         send_event(PLAYBACK_EVENT_TRACK_BUFFER, cur_id3);
1518     }
1519
1520     buf_pin_handle(info->id3_hid, false);
1521     return true;
1522
1523     (void)auto_skip; /* ifndef HAVE_TAGCACHE */
1524 }
1525
1526
1527 /** --- Audio thread --- **/
1528
1529 /* Load and parse a cuesheet for the file - returns false if the buffer
1530    is full */
1531 static bool audio_load_cuesheet(struct track_info *info,
1532                                 struct mp3entry *track_id3)
1533 {
1534     struct cuesheet *cue = get_current_cuesheet();
1535     track_id3->cuesheet = NULL;
1536
1537     if (cue && info->cuesheet_hid == ERR_HANDLE_NOT_FOUND)
1538     {
1539         /* If error other than a full buffer, then mark it "unsupported" to
1540            avoid reloading attempt */
1541         int hid = ERR_UNSUPPORTED_TYPE;
1542         struct cuesheet_file cue_file;
1543
1544 #ifdef HAVE_IO_PRIORITY
1545         buf_back_off_storage(true);
1546 #endif
1547         if (look_for_cuesheet_file(track_id3, &cue_file))
1548         {
1549             hid = bufalloc(NULL, sizeof (struct cuesheet), TYPE_CUESHEET);
1550
1551             if (hid >= 0)
1552             {
1553                 void *cuesheet = NULL;
1554                 bufgetdata(hid, sizeof (struct cuesheet), &cuesheet);
1555
1556                 if (parse_cuesheet(&cue_file, (struct cuesheet *)cuesheet))
1557                 {
1558                     /* Indicate cuesheet is present (while track remains
1559                        buffered) */
1560                     track_id3->cuesheet = cue;
1561                 }
1562                 else
1563                 {
1564                     bufclose(hid);
1565                     hid = ERR_UNSUPPORTED_TYPE;
1566                 }
1567             }
1568         }
1569
1570 #ifdef HAVE_IO_PRIORITY
1571         buf_back_off_storage(false);
1572 #endif
1573         if (hid == ERR_BUFFER_FULL)
1574         {
1575             logf("buffer is full for now (%s)", __func__);
1576             return false;
1577         }
1578         else
1579         {
1580             if (hid < 0)
1581                 logf("Cuesheet loading failed");
1582
1583             info->cuesheet_hid = hid;
1584         }
1585     }
1586
1587     return true;
1588 }
1589
1590 #ifdef HAVE_ALBUMART
1591 /* Load any album art for the file - returns false if the buffer is full */
1592 static bool audio_load_albumart(struct track_info *info,
1593                                 struct mp3entry *track_id3)
1594 {
1595     int i;
1596     FOREACH_ALBUMART(i)
1597     {
1598         struct bufopen_bitmap_data user_data;
1599         int *aa_hid = &info->aa_hid[i];
1600         int hid = ERR_UNSUPPORTED_TYPE;
1601
1602         /* albumart_slots may change during a yield of bufopen,
1603          * but that's no problem */
1604         if (*aa_hid >= 0 || *aa_hid == ERR_UNSUPPORTED_TYPE ||
1605             !albumart_slots[i].used)
1606             continue;
1607
1608         memset(&user_data, 0, sizeof(user_data));
1609         user_data.dim = &albumart_slots[i].dim;
1610
1611 #ifdef HAVE_IO_PRIORITY
1612         buf_back_off_storage(true);
1613 #endif
1614
1615         /* We can only decode jpeg for embedded AA */
1616         if (track_id3->has_embedded_albumart && track_id3->albumart.type == AA_TYPE_JPG)
1617         {
1618             user_data.embedded_albumart = &track_id3->albumart;
1619             hid = bufopen(track_id3->path, 0, TYPE_BITMAP, &user_data);
1620         }
1621
1622         if (hid < 0 && hid != ERR_BUFFER_FULL)
1623         {
1624             /* No embedded AA or it couldn't be loaded - try other sources */
1625             char path[MAX_PATH];
1626
1627             if (find_albumart(track_id3, path, sizeof(path),
1628                               &albumart_slots[i].dim))
1629             {
1630                 user_data.embedded_albumart = NULL;
1631                 hid = bufopen(path, 0, TYPE_BITMAP, &user_data);
1632             }
1633         }
1634
1635 #ifdef HAVE_IO_PRIORITY
1636         buf_back_off_storage(false);
1637 #endif
1638         if (hid == ERR_BUFFER_FULL)
1639         {
1640             logf("buffer is full for now (%s)", __func__);
1641             return false;
1642         }
1643         else
1644         {
1645             /* If error other than a full buffer, then mark it "unsupported"
1646                to avoid reloading attempt */
1647             if (hid < 0)
1648             {
1649                 logf("Album art loading failed");
1650                 hid = ERR_UNSUPPORTED_TYPE;
1651             }
1652
1653             *aa_hid = hid;
1654         }
1655     }
1656
1657     return true;
1658 }
1659 #endif /* HAVE_ALBUMART */
1660
1661 #ifdef HAVE_CODEC_BUFFERING
1662 /* Load a codec for the file onto the buffer - assumes we're working from the
1663    currently loading track - not called for the current track */
1664 static bool audio_buffer_codec(struct track_info *track_info,
1665                                struct mp3entry *track_id3)
1666 {
1667     /* This will not be the current track -> it cannot be the first and the
1668        current track cannot be ahead of buffering -> there is a previous
1669        track entry which is either current or ahead of the current */
1670     struct track_info *prev_info = track_list_last(-1);
1671     struct mp3entry *prev_id3 = bufgetid3(prev_info->id3_hid);
1672
1673     /* If the previous codec is the same as this one, there is no need to
1674        put another copy of it on the file buffer (in other words, only
1675        buffer codecs at format transitions) */
1676     if (prev_id3)
1677     {
1678         int codt = get_audio_base_codec_type(track_id3->codectype);
1679         int prev_codt = get_audio_base_codec_type(prev_id3->codectype);
1680
1681         if (codt == prev_codt)
1682         {
1683             logf("Reusing prev. codec: %d", prev_id3->codectype);
1684             return true;
1685         }
1686     }
1687     /* else just load it (harmless) */
1688
1689     /* Load the codec onto the buffer if possible */
1690     const char *codec_fn = get_codec_filename(track_id3->codectype);
1691     if (!codec_fn)
1692         return false;
1693
1694     char codec_path[MAX_PATH+1]; /* Full path to codec */
1695     codec_get_full_path(codec_path, codec_fn);
1696
1697     track_info->codec_hid = bufopen(codec_path, 0, TYPE_CODEC, NULL);
1698
1699     if (track_info->codec_hid >= 0)
1700     {
1701         logf("Buffered codec: %d", afmt);
1702         return true;
1703     }
1704
1705     return false;
1706 }
1707 #endif /* HAVE_CODEC_BUFFERING */
1708
1709 /* Load metadata for the next track (with bufopen). The rest of the track
1710    loading will be handled by audio_finish_load_track once the metadata has
1711    been actually loaded by the buffering thread.
1712
1713    Each track is arranged in the buffer as follows:
1714         <id3|[cuesheet|][album art|][codec|]audio>
1715
1716    The next will not be loaded until the previous succeeds if the buffer was
1717    full at the time. To put any metadata after audio would make those handles
1718    unmovable.
1719 */
1720 static int audio_load_track(void)
1721 {
1722     if (in_progress_id3_hid >= 0)
1723     {
1724         /* There must be an info pointer if the in-progress id3 is even there */
1725         struct track_info *info = track_list_last(0);
1726
1727         if (info->id3_hid == in_progress_id3_hid)
1728         {
1729             if (filling == STATE_FILLING)
1730             {
1731                 /* Haven't finished the metadata but the notification is
1732                    anticipated to come soon */
1733                 logf("%s(): in progress ok: %d". __func__, info->id3_hid);
1734                 return LOAD_TRACK_OK;
1735             }
1736             else if (filling == STATE_FULL)
1737             {
1738                 /* Buffer was full trying to complete the load after the
1739                    metadata finished, so attempt to continue - older handles
1740                    should have been cleared already */
1741                 logf("%s(): finishing load: %d". __func__, info->id3_hid);
1742                 filling = STATE_FILLING;
1743                 buffer_event_finished_callback(&info->id3_hid);
1744                 return LOAD_TRACK_OK;
1745             }
1746         }
1747
1748         /* Some old, stray buffering message */
1749         logf("%s(): already in progress: %d". __func__, info->id3_hid);
1750         return LOAD_TRACK_ERR_BUSY;
1751     }
1752
1753     filling = STATE_FILLING;
1754
1755     struct track_info *info = track_list_alloc_track();
1756     if (info == NULL)
1757     {
1758         /* List is full so stop buffering tracks - however, attempt to obtain
1759            metadata as the unbuffered id3 */
1760         logf("No free tracks");
1761         filling = STATE_FULL;
1762     }
1763
1764     playlist_peek_offset++;
1765
1766     logf("Buffering track: s%u/c%u/e%u/p%d",
1767          track_list.start, track_list.current, track_list.end,
1768          playlist_peek_offset);
1769
1770     /* Get track name from current playlist read position */
1771     int fd = -1;
1772     char name_buf[MAX_PATH + 1];
1773     const char *trackname;
1774
1775     while (1)
1776     {
1777
1778         trackname = playlist_peek(playlist_peek_offset, name_buf,
1779                                   sizeof (name_buf));
1780
1781         if (!trackname)
1782             break;
1783
1784         /* Test for broken playlists by probing for the files */
1785         fd = open(trackname, O_RDONLY);
1786         if (fd >= 0)
1787             break;
1788
1789         logf("Open failed");
1790         /* Skip invalid entry from playlist */
1791         playlist_skip_entry(NULL, playlist_peek_offset);
1792
1793         /* Sync the playlist if it isn't finished */
1794         if (playlist_peek(playlist_peek_offset, NULL, 0))
1795             playlist_next(0);
1796     }
1797
1798     if (!trackname)
1799     {
1800         /* No track - exhausted the playlist entries */
1801         logf("End-of-playlist");
1802         id3_write_locked(UNBUFFERED_ID3, NULL);
1803
1804         if (filling != STATE_FULL)
1805             track_list_unalloc_track(); /* Free this entry */
1806
1807         playlist_peek_offset--;         /* Maintain at last index */
1808
1809         /* We can end up here after the real last track signals its completion
1810            and miss the transition to STATE_FINISHED esp. if dropping the last
1811            songs of a playlist late in their load (2nd stage) */
1812         info = track_list_last(0);
1813
1814         if (info && buf_handle_remaining(info->audio_hid) == 0)
1815             filling_is_finished();
1816         else
1817             filling = STATE_END_OF_PLAYLIST;
1818
1819         return LOAD_TRACK_ERR_NO_MORE;
1820     }
1821
1822     /* Successfully opened the file - get track metadata */
1823     if (filling == STATE_FULL ||
1824         (info->id3_hid = bufopen(trackname, 0, TYPE_ID3, NULL)) < 0)
1825     {
1826         /* Buffer or track list is full */
1827         struct mp3entry *ub_id3;
1828
1829         playlist_peek_offset--;
1830
1831         /* Load the metadata for the first unbuffered track */
1832         ub_id3 = id3_get(UNBUFFERED_ID3);
1833         id3_mutex_lock();
1834         get_metadata(ub_id3, fd, trackname);
1835         id3_mutex_unlock();
1836
1837         if (filling != STATE_FULL)
1838         {
1839             track_list_unalloc_track();
1840             filling = STATE_FULL;
1841         }
1842
1843         logf("%s: buffer is full for now (%u tracks)", __func__,
1844              track_list_count());
1845     }
1846     else
1847     {
1848         /* Successful load initiation */
1849         info->filesize = filesize(fd);
1850         in_progress_id3_hid = info->id3_hid; /* Remember what's in-progress */
1851     }
1852
1853     close(fd);
1854     return LOAD_TRACK_OK;
1855 }
1856
1857 /* Second part of the track loading: We now have the metadata available, so we
1858    can load the codec, the album art and finally the audio data.
1859    This is called on the audio thread after the buffering thread calls the
1860    buffering_handle_finished_callback callback. */
1861 static int audio_finish_load_track(struct track_info *info)
1862 {
1863     int trackstat = LOAD_TRACK_OK;
1864
1865     if (info->id3_hid != in_progress_id3_hid)
1866     {
1867         /* We must not be here if not! */
1868         logf("%s: wrong track %d/%d", __func__, info->id3_hid,
1869              in_progress_id3_hid);
1870         return LOAD_TRACK_ERR_BUSY;
1871     }
1872
1873     /* The current track for decoding (there is always one if the list is
1874        populated) */
1875     struct track_info *cur_info = track_list_current(0);
1876     struct mp3entry *track_id3 = valid_mp3entry(bufgetid3(info->id3_hid));
1877
1878     if (!track_id3)
1879     {
1880         /* This is an error condition. Track cannot be played without valid
1881            metadata; skip the track. */
1882         logf("No metadata");
1883         trackstat = LOAD_TRACK_ERR_FINISH_FAILED;
1884         goto audio_finish_load_track_exit;
1885     }
1886
1887     /* Try to load a cuesheet for the track */
1888     if (!audio_load_cuesheet(info, track_id3))
1889     {
1890         /* No space for cuesheet on buffer, not an error */
1891         filling = STATE_FULL;
1892         goto audio_finish_load_track_exit;
1893     }
1894
1895 #ifdef HAVE_ALBUMART
1896     /* Try to load album art for the track */
1897     if (!audio_load_albumart(info, track_id3))
1898     {
1899         /* No space for album art on buffer, not an error */
1900         filling = STATE_FULL;
1901         goto audio_finish_load_track_exit;
1902     }
1903 #endif
1904
1905     /* All handles available to external routines are ready - audio and codec
1906        information is private */
1907
1908     if (info == track_list_user_current(0))
1909     {
1910         /* Send only when the track handles could not all be opened ahead of
1911            time for the user's current track - otherwise everything is ready
1912            by the time PLAYBACK_EVENT_TRACK_CHANGE is sent */
1913         send_event(PLAYBACK_EVENT_CUR_TRACK_READY, id3_get(PLAYING_ID3));
1914     }
1915
1916 #ifdef HAVE_CODEC_BUFFERING
1917     /* Try to buffer a codec for the track */
1918     if (info != cur_info && !audio_buffer_codec(info, track_id3))
1919     {
1920         if (info->codec_hid == ERR_BUFFER_FULL)
1921         {
1922             /* No space for codec on buffer, not an error */
1923             filling = STATE_FULL;
1924             logf("buffer is full for now (%s)", __func__);
1925         }
1926         else
1927         {
1928             /* This is an error condition, either no codec was found, or
1929                reading the codec file failed part way through, either way,
1930                skip the track */
1931             logf("No codec for: %s", track_id3->path);
1932             trackstat = LOAD_TRACK_ERR_FINISH_FAILED;
1933         }
1934
1935         goto audio_finish_load_track_exit;
1936     }
1937 #endif /* HAVE_CODEC_BUFFERING */
1938
1939     /** Finally, load the audio **/
1940     size_t file_offset = 0;
1941     track_id3->elapsed = 0;
1942
1943     if (track_id3->offset >= info->filesize)
1944         track_id3->offset = 0;
1945
1946     logf("%s: set offset for %s to %lu\n", __func__,
1947          id3->title, (unsigned long)offset);
1948
1949     /* Adjust for resume rewind so we know what to buffer - starting the codec
1950        calls it again, so we don't save it (and they shouldn't accumulate) */
1951     size_t offset = resume_rewind_adjusted_offset(track_id3);
1952
1953     enum data_type audiotype = rbcodec_format_is_atomic(track_id3->codectype) ?
1954                                       TYPE_ATOMIC_AUDIO : TYPE_PACKET_AUDIO;
1955
1956     if (audiotype == TYPE_ATOMIC_AUDIO)
1957         logf("Loading atomic %d", track_id3->codectype);
1958
1959     if (format_buffers_with_offset(track_id3->codectype))
1960     {
1961         /* This format can begin buffering from any point */
1962         file_offset = offset;
1963     }
1964
1965     logf("load track: %s", track_id3->path);
1966
1967     if (file_offset > AUDIO_REBUFFER_GUESS_SIZE)
1968     {
1969         /* We can buffer later in the file, adjust the hunt-and-peck margin */
1970         file_offset -= AUDIO_REBUFFER_GUESS_SIZE;
1971     }
1972     else
1973     {
1974         /* No offset given or it is very minimal - begin at the first frame
1975            according to the metadata */
1976         file_offset = track_id3->first_frame_offset;
1977     }
1978
1979     int hid = bufopen(track_id3->path, file_offset, audiotype, NULL);
1980
1981     if (hid >= 0)
1982     {
1983         info->audio_hid = hid;
1984
1985         if (info == cur_info)
1986         {
1987             /* This is the current track to decode - should be started now */
1988             trackstat = LOAD_TRACK_READY;
1989         }
1990     }
1991     else
1992     {
1993         /* Buffer could be full but not properly so if this is the only
1994            track! */
1995         if (hid == ERR_BUFFER_FULL && audio_track_count() > 1)
1996         {
1997             filling = STATE_FULL;
1998             logf("Buffer is full for now (%s)", __func__);
1999         }
2000         else
2001         {
2002             /* Nothing to play if no audio handle - skip this */
2003             logf("Could not add audio data handle");
2004             trackstat = LOAD_TRACK_ERR_FINISH_FAILED;
2005         }
2006     }
2007
2008 audio_finish_load_track_exit:
2009     if (trackstat < LOAD_TRACK_OK)
2010     {
2011         playlist_skip_entry(NULL, playlist_peek_offset);
2012         track_info_close(info);
2013         track_list_unalloc_track();
2014
2015         if (playlist_peek(playlist_peek_offset, NULL, 0))
2016             playlist_next(0);
2017
2018         playlist_peek_offset--;
2019     }
2020
2021     if (filling != STATE_FULL)
2022     {
2023         /* Load next track - error or not */
2024         in_progress_id3_hid = ERR_HANDLE_NOT_FOUND;
2025         LOGFQUEUE("audio > audio Q_AUDIO_FILL_BUFFER");
2026         audio_queue_post(Q_AUDIO_FILL_BUFFER, 0);
2027     }
2028     else
2029     {
2030         /* Full */
2031         trackstat = LOAD_TRACK_ERR_FINISH_FULL;
2032     }
2033
2034     return trackstat;
2035 }
2036
2037 /* Start a new track load */
2038 static int audio_fill_file_buffer(void)
2039 {
2040     if (play_status == PLAY_STOPPED)
2041         return LOAD_TRACK_ERR_FAILED;
2042
2043     trigger_cpu_boost();
2044
2045     /* Must reset the buffer before use if trashed or voice only - voice
2046        file size shouldn't have changed so we can go straight from
2047        AUDIOBUF_STATE_VOICED_ONLY to AUDIOBUF_STATE_INITIALIZED */
2048     if (buffer_state != AUDIOBUF_STATE_INITIALIZED)
2049         audio_reset_buffer(AUDIOBUF_STATE_INITIALIZED);
2050
2051     logf("Starting buffer fill");
2052
2053     int trackstat = audio_load_track();
2054
2055     if (trackstat >= LOAD_TRACK_OK)
2056     {
2057         if (track_list_current(0) == track_list_user_current(0))
2058             playlist_next(0);
2059
2060         if (filling == STATE_FULL && !track_list_user_current(1))
2061         {
2062             /* There are no user tracks on the buffer after this therefore
2063                this is the next track */
2064             audio_update_and_announce_next_track(id3_get(UNBUFFERED_ID3));
2065         }
2066     }
2067
2068     return trackstat;
2069 }
2070
2071 /* Discard unwanted tracks and start refill from after the specified playlist
2072    offset */
2073 static int audio_reset_and_rebuffer(
2074     enum track_clear_action action, int peek_offset)
2075 {
2076     logf("Forcing rebuffer: 0x%X, %d", flags, peek_offset);
2077
2078     id3_write_locked(UNBUFFERED_ID3, NULL);
2079
2080     /* Remove unwanted tracks - caller must have ensured codec isn't using
2081        any */
2082     track_list_clear(action);
2083
2084     /* Refill at specified position (-1 starts at index offset 0) */
2085     playlist_peek_offset = peek_offset;
2086
2087     /* Fill the buffer */
2088     return audio_fill_file_buffer();
2089 }
2090
2091 /* Handle buffering events
2092    (Q_AUDIO_BUFFERING) */
2093 static void audio_on_buffering(int event)
2094 {
2095     enum track_clear_action action;
2096     int peek_offset;
2097
2098     if (track_list_empty())
2099         return;
2100
2101     switch (event)
2102     {
2103     case BUFFER_EVENT_BUFFER_LOW:
2104         if (filling != STATE_FULL && filling != STATE_END_OF_PLAYLIST)
2105             return; /* Should be nothing left to fill */
2106
2107         /* Clear old tracks and continue buffering where it left off */
2108         action = TRACK_LIST_KEEP_NEW;
2109         peek_offset = playlist_peek_offset;
2110         break;
2111
2112     case BUFFER_EVENT_REBUFFER:
2113         /* Remove all but the currently decoding track and redo buffering
2114            after that */
2115         action = TRACK_LIST_KEEP_CURRENT;
2116         peek_offset = (skip_pending == TRACK_SKIP_AUTO) ? 1 : 0;
2117         break;
2118
2119     default:
2120         return;
2121     }
2122
2123     switch (skip_pending)
2124     {
2125     case TRACK_SKIP_NONE:
2126     case TRACK_SKIP_AUTO:
2127     case TRACK_SKIP_AUTO_NEW_PLAYLIST:
2128         audio_reset_and_rebuffer(action, peek_offset);
2129         break;
2130
2131     case TRACK_SKIP_AUTO_END_PLAYLIST:
2132         /* Already finished */
2133         break;
2134
2135     default:
2136         /* Invalid */
2137         logf("Buffering call, inv. state: %d", (int)skip_pending);
2138     }
2139 }
2140
2141 /* Handle starting the next track load
2142    (Q_AUDIO_FILL_BUFFER) */
2143 static void audio_on_fill_buffer(void)
2144 {
2145     audio_handle_track_load_status(audio_fill_file_buffer());
2146 }
2147
2148 /* Handle posted load track finish event
2149    (Q_AUDIO_FINISH_LOAD_TRACK) */
2150 static void audio_on_finish_load_track(int id3_hid)
2151 {
2152     struct track_info *info = track_list_last(0);
2153
2154     if (!info || !buf_is_handle(id3_hid))
2155         return;
2156
2157     if (info == track_list_user_current(1))
2158     {
2159         /* Just loaded the metadata right after the current position */
2160         audio_update_and_announce_next_track(bufgetid3(info->id3_hid));
2161     }
2162
2163     if (audio_finish_load_track(info) != LOAD_TRACK_READY)
2164         return; /* Not current track */
2165
2166     bool is_user_current = info == track_list_user_current(0);
2167
2168     if (is_user_current)
2169     {
2170         /* Copy cuesheet */
2171         buf_read_cuesheet(info->cuesheet_hid);
2172     }
2173
2174     if (audio_start_codec(automatic_skip))
2175     {
2176         if (is_user_current)
2177         {
2178             /* Be sure all tagtree info is synchronized; it will be needed for the
2179                track finish event - the sync will happen when finalizing a track
2180                change otherwise */
2181             bool was_valid = valid_mp3entry(id3_get(PLAYING_ID3));
2182
2183             playing_id3_sync(info, -1);
2184
2185             if (!was_valid)
2186             {
2187                 /* Playing id3 hadn't been updated yet because no valid track
2188                    was yet available - treat like the first track */
2189                 audio_playlist_track_change();
2190             }
2191         }
2192     }
2193     else
2194     {
2195         audio_handle_track_load_status(LOAD_TRACK_ERR_START_CODEC);
2196     }
2197 }
2198
2199 /* Called when handles other than metadata handles have finished buffering
2200    (Q_AUDIO_HANDLE_FINISHED) */
2201 static void audio_on_handle_finished(int hid)
2202 {
2203     /* Right now, only audio handles should end up calling this */
2204     if (filling == STATE_END_OF_PLAYLIST)
2205     {
2206         struct track_info *info = track_list_last(0);
2207
2208         /* Really we don't know which order the handles will actually complete
2209            to zero bytes remaining since another thread is doing it - be sure
2210            it's the right one */
2211         if (info && info->audio_hid == hid)
2212         {
2213             /* This was the last track in the playlist and we now have all the
2214                data we need */
2215             filling_is_finished();
2216         }
2217     }
2218 }
2219
2220 /* Called to make an outstanding track skip the current track and to send the
2221    transition events */
2222 static void audio_finalise_track_change(void)
2223 {
2224     switch (skip_pending)
2225     {
2226     case TRACK_SKIP_NONE: /* Manual skip */
2227         break;
2228
2229     case TRACK_SKIP_AUTO:
2230     case TRACK_SKIP_AUTO_NEW_PLAYLIST:
2231     {
2232         int playlist_delta = skip_pending == TRACK_SKIP_AUTO ? 1 : 0;
2233         audio_playlist_track_finish();
2234
2235         if (!playlist_peek(playlist_delta, NULL, 0))
2236         {
2237             /* Track ended up rejected - push things ahead like the codec blew
2238                it (because it was never started and now we're here where it
2239                should have been decoding the next track by now) - next, a
2240                directory change or end of playback will most likely happen */
2241             skip_pending = TRACK_SKIP_NONE;
2242             audio_handle_track_load_status(LOAD_TRACK_ERR_START_CODEC);
2243             return;
2244         }
2245
2246         if (!playlist_delta)
2247             break;
2248
2249         playlist_peek_offset -= playlist_delta;
2250         if (playlist_next(playlist_delta) >= 0)
2251             break;
2252             /* What!? Disappear? Hopeless bleak despair */
2253         }
2254         /* Fallthrough */
2255     case TRACK_SKIP_AUTO_END_PLAYLIST:
2256     default:            /* Invalid */
2257         filling = STATE_ENDED;
2258         audio_stop_playback();
2259         return;
2260     }
2261
2262     struct track_info *info = track_list_current(0);
2263     struct mp3entry *track_id3 = NULL;
2264
2265     id3_mutex_lock();
2266
2267     /* Update the current cuesheet if any and enabled */
2268     if (info)
2269     {
2270         buf_read_cuesheet(info->cuesheet_hid);
2271         track_id3 = bufgetid3(info->id3_hid);
2272     }
2273
2274     id3_write(PLAYING_ID3, track_id3);
2275
2276     /* The skip is technically over */
2277     skip_pending = TRACK_SKIP_NONE;
2278
2279     /* Sync the next track information */
2280     info = track_list_current(1);
2281
2282     id3_write(NEXTTRACK_ID3, info ? bufgetid3(info->id3_hid) :
2283                                     id3_get(UNBUFFERED_ID3));
2284
2285     id3_mutex_unlock();
2286
2287     audio_playlist_track_change();
2288 }
2289
2290 /* Actually begin a transition and take care of the codec change - may complete
2291    it now or ask pcmbuf for notification depending on the type */
2292 static void audio_begin_track_change(enum pcm_track_change_type type,
2293                                      int trackstat)
2294 {
2295     /* Even if the new track is bad, the old track must be finished off */
2296     pcmbuf_start_track_change(type);
2297
2298     bool auto_skip = type != TRACK_CHANGE_MANUAL;
2299
2300     if (!auto_skip)
2301     {
2302         /* Manual track change happens now */
2303         audio_finalise_track_change();
2304         pcmbuf_sync_position_update();
2305
2306         if (play_status == PLAY_STOPPED)
2307             return; /* Stopped us */
2308     }
2309
2310     if (trackstat >= LOAD_TRACK_OK)
2311     {
2312         struct track_info *info = track_list_current(0);
2313
2314         if (info->audio_hid < 0)
2315             return;
2316
2317         /* Everything needed for the codec is ready - start it */
2318         if (audio_start_codec(auto_skip))
2319         {
2320             if (!auto_skip)
2321                 playing_id3_sync(info, -1);
2322             return;
2323         }
2324
2325         trackstat = LOAD_TRACK_ERR_START_CODEC;
2326     }
2327
2328     audio_handle_track_load_status(trackstat);
2329 }
2330
2331 /* Transition to end-of-playlist state and begin wait for PCM to finish */
2332 static void audio_monitor_end_of_playlist(void)
2333 {
2334     skip_pending = TRACK_SKIP_AUTO_END_PLAYLIST;
2335     filling = STATE_ENDING;
2336     pcmbuf_start_track_change(TRACK_CHANGE_END_OF_DATA);
2337 }
2338
2339 /* Codec has completed decoding the track
2340    (usually Q_AUDIO_CODEC_COMPLETE) */
2341 static void audio_on_codec_complete(int status)
2342 {
2343     logf("%s(%d)", __func__, status);
2344
2345     if (play_status == PLAY_STOPPED)
2346         return;
2347
2348     /* If it didn't notify us first, don't expect "seek complete" message
2349        since the codec can't post it now - do things like it would have
2350        done */
2351     audio_complete_codec_seek();
2352
2353     if (play_status == PLAY_PAUSED || skip_pending != TRACK_SKIP_NONE)
2354     {
2355         /* Old-hay on the ip-skay - codec has completed decoding
2356
2357            Paused: We're not sounding it, so just remember that it happened
2358                    and the resume will begin the transition
2359
2360            Skipping: There was already a skip in progress, remember it and
2361                      allow no further progress until the PCM from the previous
2362                      song has finished
2363          */
2364         codec_skip_pending = true;
2365         codec_skip_status = status;
2366         return;
2367     }
2368
2369     codec_skip_pending = false;
2370
2371     int trackstat = LOAD_TRACK_OK;
2372
2373     automatic_skip = true;
2374     skip_pending = TRACK_SKIP_AUTO;
2375
2376     /* Does this track have an entry allocated? */
2377     struct track_info *info = track_list_advance_current(1);
2378
2379     if (!info || info->audio_hid < 0)
2380     {
2381         bool end_of_playlist = false;
2382
2383         if (info)
2384         {
2385             /* Track load is not complete - it might have stopped on a
2386                full buffer without reaching the audio handle or we just
2387                arrived at it early
2388
2389                If this type is atomic and we couldn't get the audio,
2390                perhaps it would need to wrap to make the allocation and
2391                handles are in the way - to maximize the liklihood it can
2392                be allocated, clear all handles to reset the buffer and
2393                its indexes to 0 - for packet audio, this should not be an
2394                issue and a pointless full reload of all the track's
2395                metadata may be avoided */
2396
2397             struct mp3entry *track_id3 = bufgetid3(info->id3_hid);
2398
2399             if (track_id3 && !rbcodec_format_is_atomic(track_id3->codectype))
2400             {
2401                 /* Continue filling after this track */
2402                 audio_reset_and_rebuffer(TRACK_LIST_KEEP_CURRENT, 1);
2403                 audio_begin_track_change(TRACK_CHANGE_AUTO, trackstat);
2404                 return;
2405             }
2406             /* else rebuffer at this track; status applies to the track we
2407                want */
2408         }
2409         else if (!playlist_peek(1, NULL, 0))
2410         {
2411             /* Play sequence is complete - directory change or other playlist
2412                resequencing - the playlist must now be advanced in order to
2413                continue since a peek ahead to the next track is not possible */
2414             skip_pending = TRACK_SKIP_AUTO_NEW_PLAYLIST;
2415             end_of_playlist = playlist_next(1) < 0;
2416         }
2417
2418         if (!end_of_playlist)
2419         {
2420             trackstat = audio_reset_and_rebuffer(TRACK_LIST_CLEAR_ALL,
2421                             skip_pending == TRACK_SKIP_AUTO ? 0 : -1);
2422
2423             if (trackstat == LOAD_TRACK_ERR_NO_MORE)
2424             {
2425                 /* Failed to find anything after all - do playlist switchover
2426                    instead */
2427                 skip_pending = TRACK_SKIP_AUTO_NEW_PLAYLIST;
2428                 end_of_playlist = playlist_next(1) < 0;
2429             }
2430         }
2431
2432         if (end_of_playlist)
2433         {
2434             audio_monitor_end_of_playlist();
2435             return;
2436         }
2437     }
2438
2439     audio_begin_track_change(TRACK_CHANGE_AUTO, trackstat);
2440 }
2441
2442 /* Called when codec completes seek operation
2443    (usually Q_AUDIO_CODEC_SEEK_COMPLETE) */
2444 static void audio_on_codec_seek_complete(void)
2445 {
2446     logf("%s()", __func__);
2447     audio_complete_codec_seek();
2448     codec_go();
2449 }
2450
2451 /* Called when PCM track change has completed
2452    (Q_AUDIO_TRACK_CHANGED) */
2453 static void audio_on_track_changed(void)
2454 {
2455     /* Finish whatever is pending so that the WPS is in sync */
2456     audio_finalise_track_change();
2457
2458     if (codec_skip_pending)
2459     {
2460         /* Codec got ahead completing a short track - complete the
2461            codec's skip and begin the next */
2462         codec_skip_pending = false;
2463         audio_on_codec_complete(codec_skip_status);
2464     }
2465 }
2466
2467 /* Begin playback from an idle state, transition to a new playlist or
2468    invalidate the buffer and resume (if playing).
2469    (usually Q_AUDIO_PLAY, Q_AUDIO_REMAKE_AUDIO_BUFFER) */
2470 static void audio_start_playback(size_t offset, unsigned int flags)
2471 {
2472     enum play_status old_status = play_status;
2473
2474     if (flags & AUDIO_START_NEWBUF)
2475     {
2476         /* Mark the buffer dirty - if not playing, it will be reset next
2477            time */
2478         if (buffer_state == AUDIOBUF_STATE_INITIALIZED)
2479             buffer_state = AUDIOBUF_STATE_VOICED_ONLY;
2480     }
2481
2482     if (old_status != PLAY_STOPPED)
2483     {
2484         logf("%s(%lu): skipping", __func__, (unsigned long)offset);
2485
2486         halt_decoding_track(true);
2487
2488         automatic_skip = false;
2489         ff_rw_mode = false;
2490
2491         if (flags & AUDIO_START_RESTART)
2492         {
2493             /* Clear out some stuff to resume the current track where it
2494                left off */
2495             pcmbuf_play_stop();
2496             offset = id3_get(PLAYING_ID3)->offset;
2497             track_list_clear(TRACK_LIST_CLEAR_ALL);
2498         }
2499         else
2500         {
2501             /* This is more-or-less treated as manual track transition */
2502             /* Save resume information for current track */
2503             audio_playlist_track_finish();
2504             track_list_clear(TRACK_LIST_CLEAR_ALL);
2505
2506             /* Indicate manual track change */
2507             pcmbuf_start_track_change(TRACK_CHANGE_MANUAL);
2508             wipe_track_metadata(true);
2509         }
2510
2511         /* Set after track finish event in case skip was in progress */
2512         skip_pending = TRACK_SKIP_NONE;
2513     }
2514     else
2515     {
2516         if (flags & AUDIO_START_RESTART)
2517             return; /* Must already be playing */
2518
2519         /* Cold playback start from a stopped state */
2520         logf("%s(%lu): starting", __func__, offset);
2521
2522         /* Set audio parameters */
2523 #if INPUT_SRC_CAPS != 0
2524         audio_set_input_source(AUDIO_SRC_PLAYBACK, SRCF_PLAYBACK);
2525         audio_set_output_source(AUDIO_SRC_PLAYBACK);
2526 #endif
2527 #ifndef PLATFORM_HAS_VOLUME_CHANGE
2528         sound_set_volume(global_settings.volume);
2529 #endif
2530         /* Be sure channel is audible */
2531         pcmbuf_fade(false, true);
2532
2533         /* Update our state */
2534         play_status = PLAY_PLAYING;
2535     }
2536
2537     /* Codec's position should be available as soon as it knows it */
2538     position_key = pcmbuf_get_position_key();
2539     pcmbuf_sync_position_update();
2540
2541     /* Start fill from beginning of playlist */
2542     playlist_peek_offset = -1;
2543     buf_set_base_handle(-1);
2544
2545     /* Officially playing */
2546     queue_reply(&audio_queue, 1);
2547
2548     /* Add these now - finish event for the first id3 will most likely be sent
2549        immediately */
2550     add_event(BUFFER_EVENT_REBUFFER, false, buffer_event_rebuffer_callback);
2551     add_event(BUFFER_EVENT_FINISHED, false, buffer_event_finished_callback);
2552
2553     if (old_status == PLAY_STOPPED)
2554     {
2555         /* Send coldstart event */
2556         send_event(PLAYBACK_EVENT_START_PLAYBACK, NULL);
2557     }
2558
2559     /* Fill the buffer */
2560     int trackstat = audio_fill_file_buffer();
2561
2562     if (trackstat >= LOAD_TRACK_OK)
2563     {
2564         /* This is the currently playing track - get metadata, stat */
2565         playing_id3_sync(track_list_current(0), offset);
2566
2567         if (valid_mp3entry(id3_get(PLAYING_ID3)))
2568         {
2569             /* Only if actually changing tracks... */
2570             if (!(flags & AUDIO_START_RESTART))
2571                 audio_playlist_track_change();
2572         }
2573     }
2574     else
2575     {
2576         /* Found nothing playable */
2577         audio_handle_track_load_status(trackstat);
2578     }
2579 }
2580
2581 /* Stop playback and enter an idle state
2582    (usually Q_AUDIO_STOP) */
2583 static void audio_stop_playback(void)
2584 {
2585     logf("%s()", __func__);
2586
2587     if (play_status == PLAY_STOPPED)
2588         return;
2589
2590     bool do_fade = global_settings.fade_on_stop && filling != STATE_ENDED;
2591
2592     pcmbuf_fade(do_fade, false);
2593
2594     /* Wait for fade-out */
2595     audio_wait_fade_complete();
2596
2597     /* Stop the codec and unload it */
2598     halt_decoding_track(true);
2599     pcmbuf_play_stop();
2600     codec_unload();
2601
2602     /* Save resume information  - "filling" might have been set to
2603        "STATE_ENDED" by caller in order to facilitate end of playlist */
2604     audio_playlist_track_finish();
2605
2606     skip_pending = TRACK_SKIP_NONE;
2607     automatic_skip = false;
2608
2609     /* Close all tracks and mark them NULL */
2610     remove_event(BUFFER_EVENT_REBUFFER, buffer_event_rebuffer_callback);
2611     remove_event(BUFFER_EVENT_FINISHED, buffer_event_finished_callback);
2612     remove_event(BUFFER_EVENT_BUFFER_LOW, buffer_event_buffer_low_callback);
2613
2614     track_list_clear(TRACK_LIST_CLEAR_ALL);
2615
2616     /* Update our state */
2617     ff_rw_mode = false;
2618     play_status = PLAY_STOPPED;
2619
2620     wipe_track_metadata(true);
2621
2622     /* Go idle */
2623     filling = STATE_IDLE;
2624     cancel_cpu_boost();
2625 }
2626
2627 /* Pause the playback of the current track
2628    (Q_AUDIO_PAUSE) */
2629 static void audio_on_pause(bool pause)
2630 {
2631     logf("%s(%s)", __func__, pause ? "true" : "false");
2632
2633     if (play_status == PLAY_STOPPED || pause == (play_status == PLAY_PAUSED))
2634         return;
2635
2636     play_status = pause ? PLAY_PAUSED : PLAY_PLAYING;
2637
2638     if (!pause && codec_skip_pending)
2639     {
2640         /* Actually do the skip that is due - resets the status flag */
2641         audio_on_codec_complete(codec_skip_status);
2642     }
2643
2644     bool do_fade = global_settings.fade_on_stop;
2645
2646     pcmbuf_fade(do_fade, !pause);
2647
2648     if (!ff_rw_mode && !(do_fade && pause))
2649     {
2650         /* Not in ff/rw mode - can actually change the audio state now */
2651         pcmbuf_pause(pause);
2652     }
2653 }
2654
2655 /* Skip a certain number of tracks forwards or backwards
2656    (Q_AUDIO_SKIP) */
2657 static void audio_on_skip(void)
2658 {
2659     id3_mutex_lock();
2660
2661     /* Eat the delta to keep it synced, even if not playing */
2662     int toskip = skip_offset;
2663     skip_offset = 0;
2664
2665     logf("%s(): %d", __func__, toskip);
2666
2667     id3_mutex_unlock();
2668
2669     if (play_status == PLAY_STOPPED)
2670         return;
2671
2672     /* Force codec to abort this track */
2673     halt_decoding_track(true);
2674
2675     /* Kill the ff/rw halt */
2676     ff_rw_mode = false;
2677
2678     /* Manual skip */
2679     automatic_skip = false;
2680
2681     /* If there was an auto skip in progress, there will be residual
2682        advancement of the playlist and/or track list so compensation will be
2683        required in order to end up in the right spot */
2684     int track_list_delta = toskip;
2685     int playlist_delta = toskip;
2686
2687     if (skip_pending != TRACK_SKIP_NONE)
2688     {
2689         if (skip_pending != TRACK_SKIP_AUTO_END_PLAYLIST)
2690             track_list_delta--;
2691
2692         if (skip_pending == TRACK_SKIP_AUTO_NEW_PLAYLIST)
2693             playlist_delta--;
2694     }
2695
2696     audio_playlist_track_finish();
2697     skip_pending = TRACK_SKIP_NONE;
2698
2699     /* Update the playlist current track now */
2700     int pl_retval;
2701     while ((pl_retval = playlist_next(playlist_delta)) < 0)
2702     {
2703         if (pl_retval < -1)
2704         {
2705             /* Some variety of fatal error while updating playlist */
2706             filling = STATE_ENDED;
2707             audio_stop_playback();
2708             return;
2709         }
2710
2711         /* Manual skip out of range (because the playlist wasn't updated
2712            yet by us and so the check in audio_skip returned 'ok') - bring
2713            back into range */
2714         int d = toskip < 0 ? 1 : -1;
2715
2716         while (!playlist_check(playlist_delta))
2717         {
2718             if (playlist_delta == d)
2719             {
2720                 /* Had to move the opposite direction to correct, which is
2721                    wrong - this is the end */
2722                 filling = STATE_ENDED;
2723                 audio_stop_playback();
2724                 return;
2725             }
2726
2727             playlist_delta += d;
2728             track_list_delta += d;
2729         }
2730     }
2731
2732     /* Adjust things by how much the playlist was manually moved */
2733     playlist_peek_offset -= playlist_delta;
2734
2735     struct track_info *info = track_list_advance_current(track_list_delta);
2736     int trackstat = LOAD_TRACK_OK;
2737
2738     if (!info || info->audio_hid < 0)
2739     {
2740         /* We don't know the next track thus we know we don't have it */
2741         trackstat = audio_reset_and_rebuffer(TRACK_LIST_CLEAR_ALL, -1);
2742     }
2743
2744     audio_begin_track_change(TRACK_CHANGE_MANUAL, trackstat);
2745 }
2746
2747 /* Skip to the next/previous directory
2748    (Q_AUDIO_DIR_SKIP) */
2749 static void audio_on_dir_skip(int direction)
2750 {
2751     logf("%s(%d)", __func__, direction);
2752
2753     id3_mutex_lock();
2754     skip_offset = 0;
2755     id3_mutex_unlock();
2756
2757     if (play_status == PLAY_STOPPED)
2758         return;
2759
2760     /* Force codec to abort this track */
2761     halt_decoding_track(true);
2762
2763     /* Kill the ff/rw halt */
2764     ff_rw_mode = false;
2765
2766     /* Manual skip */
2767     automatic_skip = false;
2768
2769     audio_playlist_track_finish();
2770
2771     /* Unless automatic and gapless, skips do not pend */
2772     skip_pending = TRACK_SKIP_NONE;
2773
2774     /* Regardless of the return value we need to rebuffer. If it fails the old
2775        playlist will resume, else the next dir will start playing. */
2776     playlist_next_dir(direction);
2777
2778     wipe_track_metadata(false);
2779
2780     int trackstat = audio_reset_and_rebuffer(TRACK_LIST_CLEAR_ALL, -1);
2781
2782     if (trackstat == LOAD_TRACK_ERR_NO_MORE)
2783     {
2784         /* The day the music died - finish-off whatever is playing and call it
2785            quits */
2786         audio_monitor_end_of_playlist();
2787         return;
2788     }
2789
2790     audio_begin_track_change(TRACK_CHANGE_MANUAL, trackstat);
2791 }
2792
2793 /* Enter seek mode in order to start a seek
2794    (Q_AUDIO_PRE_FF_REWIND) */
2795 static void audio_on_pre_ff_rewind(void)
2796 {
2797     logf("%s()", __func__);
2798
2799     if (play_status == PLAY_STOPPED || ff_rw_mode)
2800         return;
2801
2802     ff_rw_mode = true;
2803
2804     audio_wait_fade_complete();
2805
2806     if (play_status == PLAY_PAUSED)
2807         return;
2808
2809     pcmbuf_pause(true);
2810 }
2811
2812 /* Seek the playback of the current track to the specified time
2813    (Q_AUDIO_FF_REWIND) */
2814 static void audio_on_ff_rewind(long time)
2815 {
2816     logf("%s(%ld)", __func__, time);
2817
2818     if (play_status == PLAY_STOPPED)
2819         return;
2820
2821     enum track_skip_type pending = skip_pending;
2822
2823     switch (pending)
2824     {
2825     case TRACK_SKIP_NONE:              /* The usual case */
2826     case TRACK_SKIP_AUTO:              /* Have to back it out (fun!) */
2827     case TRACK_SKIP_AUTO_END_PLAYLIST: /* Still have the last codec used */
2828     {
2829         struct mp3entry *id3 = id3_get(PLAYING_ID3);
2830         struct mp3entry *ci_id3 = id3_get(CODEC_ID3);
2831
2832         automatic_skip = false;
2833
2834         /* Send event before clobbering the time */
2835         /* FIXME: Nasty, but the tagtree expects this so that rewinding and
2836            then skipping back to this track resumes properly. Something else
2837            should be sent. We're not _really_ finishing the track are we? */
2838         if (time == 0)
2839             send_event(PLAYBACK_EVENT_TRACK_FINISH, id3);
2840
2841         id3->elapsed = time;
2842         queue_reply(&audio_queue, 1);
2843
2844         bool haltres = halt_decoding_track(pending == TRACK_SKIP_AUTO);
2845
2846         /* Need this set in case ff/rw mode + error but _after_ the codec
2847            halt that will reset it */
2848         codec_seeking = true;
2849
2850         /* If in transition, key will have changed - sync to it */
2851         position_key = pcmbuf_get_position_key();
2852
2853         if (pending == TRACK_SKIP_AUTO)
2854         {
2855             if (!track_list_advance_current(-1))
2856             {
2857                 /* Not in list - must rebuffer at the current playlist index */
2858                 if (audio_reset_and_rebuffer(TRACK_LIST_CLEAR_ALL, -1)
2859                         < LOAD_TRACK_OK)
2860                 {
2861                     /* Codec is stopped */
2862                     break;
2863                 }
2864             }
2865         }
2866
2867         /* Set after audio_fill_file_buffer to disable playing id3 clobber if
2868            rebuffer is needed */
2869         skip_pending = TRACK_SKIP_NONE;
2870         struct track_info *cur_info = track_list_current(0);
2871
2872         /* Track must complete the loading _now_ since a codec and audio
2873            handle are needed in order to do the seek */
2874         if (cur_info->audio_hid < 0 &&
2875             audio_finish_load_track(cur_info) != LOAD_TRACK_READY)
2876         {
2877             /* Call above should push any load sequence - no need for
2878                halt_decoding_track here if no skip was pending here because
2879                there would not be a codec started if no audio handle was yet
2880                opened */
2881             break;
2882         }
2883
2884         if (pending == TRACK_SKIP_AUTO)
2885         {
2886             if (!bufreadid3(cur_info->id3_hid, ci_id3) ||
2887                 !audio_init_codec(cur_info, ci_id3))
2888             {
2889                 /* We should have still been able to get it - skip it and move
2890                    onto the next one - like it or not this track is broken */
2891                 break;
2892             }
2893
2894             /* Set the codec API to the correct metadata and track info */
2895             ci.audio_hid = cur_info->audio_hid;
2896             ci.filesize = cur_info->filesize;
2897             buf_set_base_handle(cur_info->audio_hid);
2898         }
2899
2900         if (!haltres)
2901         {
2902             /* If codec must be (re)started, reset the offset */
2903             ci_id3->offset = 0;
2904         }
2905
2906         codec_seek(time);
2907         return;
2908         }
2909
2910     case TRACK_SKIP_AUTO_NEW_PLAYLIST:
2911     {
2912         /* We cannot do this because the playlist must be reversed by one
2913            and it doesn't always return the same song when going backwards
2914            across boundaries as forwards (either because of randomization
2915            or inconsistency in deciding what the previous track should be),
2916            therefore the whole operation would often end up as nonsense -
2917            lock out seeking for a couple seconds */
2918
2919         /* Sure as heck cancel seek mode too! */
2920         audio_ff_rewind_end();
2921         return;
2922         }
2923
2924     default:
2925         /* Won't see this */
2926         return;
2927     }
2928
2929     if (play_status == PLAY_STOPPED)
2930     {
2931         /* Playback ended because of an error completing a track load */
2932         return;
2933     }
2934
2935     /* Always fake it as a codec start error which will handle mode
2936        cancellations and skip to the next track */
2937     audio_handle_track_load_status(LOAD_TRACK_ERR_START_CODEC);
2938 }
2939
2940 /* Invalidates all but currently playing track
2941    (Q_AUDIO_FLUSH) */
2942 static void audio_on_audio_flush(void)
2943 {
2944     logf("%s", __func__);
2945
2946     if (track_list_empty())
2947         return; /* Nothing to flush out */
2948
2949     switch (skip_pending)
2950     {
2951     case TRACK_SKIP_NONE:
2952     case TRACK_SKIP_AUTO_END_PLAYLIST:
2953         /* Remove all but the currently playing track from the list and
2954            refill after that */
2955         track_list_clear(TRACK_LIST_KEEP_CURRENT);
2956         playlist_peek_offset = 0;
2957         id3_write_locked(UNBUFFERED_ID3, NULL);
2958         audio_update_and_announce_next_track(NULL);
2959
2960         /* Ignore return since it's about the next track, not this one */
2961         audio_fill_file_buffer();
2962
2963         if (skip_pending == TRACK_SKIP_NONE)
2964             break;
2965
2966         /* There's now a track after this one now - convert to auto skip -
2967            no skip should pend right now because multiple flush messages can
2968            be fired which would cause a restart in the below cases */
2969         skip_pending = TRACK_SKIP_NONE;
2970         audio_clear_track_notifications();
2971         audio_queue_post(Q_AUDIO_CODEC_COMPLETE, CODEC_OK);
2972         break;
2973
2974     case TRACK_SKIP_AUTO:
2975     case TRACK_SKIP_AUTO_NEW_PLAYLIST:
2976         /* Precisely removing what it already decoded for the next track is
2977            not possible so a restart is required in order to continue the
2978            currently playing track without the now invalid future track
2979            playing */
2980         audio_start_playback(0, AUDIO_START_RESTART);
2981         break;
2982
2983     default: /* Nothing else is a state */
2984         break;
2985     }
2986 }
2987
2988 #ifdef AUDIO_HAVE_RECORDING
2989 /* Load the requested encoder type
2990    (Q_AUDIO_LOAD_ENCODER) */
2991 static void audio_on_load_encoder(int afmt)
2992 {
2993     bool res = true;
2994
2995     if (play_status != PLAY_STOPPED)
2996         audio_stop_playback(); /* Can't load both types at once */
2997     else
2998         codec_unload(); /* Encoder still loaded, stop and unload it */
2999
3000     if (afmt != AFMT_UNKNOWN)
3001     {
3002         res = codec_load(-1, afmt | CODEC_TYPE_ENCODER);
3003         if (res)
3004             codec_go(); /* These are run immediately */
3005     }
3006
3007     queue_reply(&audio_queue, res);
3008 }
3009 #endif /* AUDIO_HAVE_RECORDING */
3010
3011 static void audio_thread(void)
3012 {
3013     struct queue_event ev;
3014
3015     pcm_postinit();
3016
3017     while (1)
3018     {
3019         switch (filling)
3020         {
3021         /* Active states */
3022         case STATE_FULL:
3023         case STATE_END_OF_PLAYLIST:
3024             if (buf_get_watermark() == 0)
3025             {
3026                 /* End of buffering for now, let's calculate the watermark,
3027                    register for a low buffer event and unboost */
3028                 audio_update_filebuf_watermark(0);
3029                 add_event(BUFFER_EVENT_BUFFER_LOW, true,
3030                           buffer_event_buffer_low_callback);
3031             }
3032             /* Fall-through */
3033         case STATE_FINISHED:
3034             /* All data was buffered */
3035             cancel_cpu_boost();
3036             /* Fall-through */
3037         case STATE_FILLING:
3038         case STATE_ENDING:
3039             if (audio_pcmbuf_track_change_scan())
3040             {
3041                 /* Transfer notification to audio queue event */
3042                 ev.id = Q_AUDIO_TRACK_CHANGED;
3043                 ev.data = 1;
3044             }
3045             else
3046             {
3047                 /* If doing auto skip, poll pcmbuf track notifications a bit
3048                    faster to promply detect the transition */
3049                 queue_wait_w_tmo(&audio_queue, &ev,
3050                                  skip_pending == TRACK_SKIP_NONE ?
3051                                     HZ/2 : HZ/10);
3052             }
3053             break;
3054
3055         /* Idle states */
3056         default:
3057             queue_wait(&audio_queue, &ev);
3058
3059 #if (CONFIG_PLATFORM & PLATFORM_NATIVE)
3060             switch (ev.id)
3061             {
3062 #ifdef AUDIO_HAVE_RECORDING
3063             /* Must monitor the encoder message for recording so it can remove
3064                it if we process the insertion before it does. It cannot simply
3065                be removed from under recording however. */
3066             case Q_AUDIO_LOAD_ENCODER:
3067                 break;
3068 #endif
3069             case SYS_USB_DISCONNECTED:
3070                 filling = STATE_IDLE;
3071                 break;
3072
3073             default:
3074                 if (filling == STATE_USB)
3075                     continue;
3076             }
3077 #endif /* CONFIG_PLATFORM */
3078         }
3079
3080         switch (ev.id)
3081         {
3082         /** Codec and track change messages **/
3083         case Q_AUDIO_CODEC_COMPLETE:
3084             /* Codec is done processing track and has gone idle */
3085             LOGFQUEUE("audio < Q_AUDIO_CODEC_COMPLETE: %ld", (long)ev.data);
3086             audio_on_codec_complete(ev.data);
3087             break;
3088
3089         case Q_AUDIO_CODEC_SEEK_COMPLETE:
3090             /* Codec is done seeking */
3091             LOGFQUEUE("audio < Q_AUDIO_SEEK_COMPLETE");
3092             audio_on_codec_seek_complete();
3093             break;
3094
3095         case Q_AUDIO_TRACK_CHANGED:
3096             /* PCM track change done */
3097             LOGFQUEUE("audio < Q_AUDIO_TRACK_CHANGED");
3098             audio_on_track_changed();
3099             break;
3100
3101         /** Control messages **/
3102         case Q_AUDIO_PLAY:
3103             LOGFQUEUE("audio < Q_AUDIO_PLAY");
3104             audio_start_playback(ev.data, 0);
3105             break;
3106
3107         case Q_AUDIO_STOP:
3108             LOGFQUEUE("audio < Q_AUDIO_STOP");
3109             audio_stop_playback();
3110             if (ev.data != 0)
3111                 queue_clear(&audio_queue);
3112             break;
3113
3114         case Q_AUDIO_PAUSE:
3115             LOGFQUEUE("audio < Q_AUDIO_PAUSE");
3116             audio_on_pause(ev.data);
3117             break;
3118
3119         case Q_AUDIO_SKIP:
3120             LOGFQUEUE("audio < Q_AUDIO_SKIP");
3121             audio_on_skip();
3122             break;
3123
3124         case Q_AUDIO_DIR_SKIP:
3125             LOGFQUEUE("audio < Q_AUDIO_DIR_SKIP");
3126             audio_on_dir_skip(ev.data);
3127             break;
3128
3129         case Q_AUDIO_PRE_FF_REWIND:
3130             LOGFQUEUE("audio < Q_AUDIO_PRE_FF_REWIND");
3131             audio_on_pre_ff_rewind();
3132             break;
3133
3134         case Q_AUDIO_FF_REWIND:
3135             LOGFQUEUE("audio < Q_AUDIO_FF_REWIND");
3136             audio_on_ff_rewind(ev.data);
3137             break;
3138
3139         case Q_AUDIO_FLUSH:
3140             LOGFQUEUE("audio < Q_AUDIO_FLUSH: %d", (int)ev.data);
3141             audio_on_audio_flush();
3142             break;
3143
3144         /** Buffering messages **/
3145         case Q_AUDIO_BUFFERING:
3146             /* some buffering event */
3147             LOGFQUEUE("audio < Q_AUDIO_BUFFERING: %d", (int)ev.data);
3148             audio_on_buffering(ev.data);
3149             break;
3150
3151         case Q_AUDIO_FILL_BUFFER:
3152             /* continue buffering next track */
3153             LOGFQUEUE("audio < Q_AUDIO_FILL_BUFFER");
3154             audio_on_fill_buffer();
3155             break;
3156
3157         case Q_AUDIO_FINISH_LOAD_TRACK:
3158             /* metadata is buffered */
3159             LOGFQUEUE("audio < Q_AUDIO_FINISH_LOAD_TRACK");
3160             audio_on_finish_load_track(ev.data);
3161             break;
3162
3163         case Q_AUDIO_HANDLE_FINISHED:
3164             /* some other type is buffered */
3165             LOGFQUEUE("audio < Q_AUDIO_HANDLE_FINISHED");
3166             audio_on_handle_finished(ev.data);
3167             break;
3168
3169         /** Miscellaneous messages **/
3170         case Q_AUDIO_REMAKE_AUDIO_BUFFER:
3171             /* buffer needs to be reinitialized */
3172             LOGFQUEUE("audio < Q_AUDIO_REMAKE_AUDIO_BUFFER");
3173             audio_start_playback(0, AUDIO_START_RESTART | AUDIO_START_NEWBUF);
3174             break;
3175
3176 #ifdef HAVE_DISK_STORAGE
3177         case Q_AUDIO_UPDATE_WATERMARK:
3178             /* buffering watermark needs updating */
3179             LOGFQUEUE("audio < Q_AUDIO_UPDATE_WATERMARK: %d", (int)ev.data);
3180             audio_update_filebuf_watermark(ev.data);
3181             break;
3182 #endif /* HAVE_DISK_STORAGE */
3183
3184 #ifdef AUDIO_HAVE_RECORDING
3185         case Q_AUDIO_LOAD_ENCODER:
3186             /* load an encoder for recording */
3187             LOGFQUEUE("audio < Q_AUDIO_LOAD_ENCODER: %d", (int)ev.data);
3188             audio_on_load_encoder(ev.data);
3189             break;
3190 #endif /* AUDIO_HAVE_RECORDING */
3191
3192         case SYS_USB_CONNECTED:
3193             LOGFQUEUE("audio < SYS_USB_CONNECTED");
3194             audio_stop_playback();
3195 #ifdef PLAYBACK_VOICE
3196             voice_stop();
3197 #endif
3198             filling = STATE_USB;
3199             usb_acknowledge(SYS_USB_CONNECTED_ACK);
3200             break;
3201
3202         case SYS_TIMEOUT:
3203             LOGFQUEUE_SYS_TIMEOUT("audio < SYS_TIMEOUT");
3204             break;
3205
3206         default:
3207             /* LOGFQUEUE("audio < default : %08lX", ev.id); */
3208             break;
3209         } /* end switch */
3210     } /* end while */
3211 }
3212
3213
3214 /* --- Buffering callbacks --- */
3215
3216 /* Called when fullness is below the watermark level */
3217 static void buffer_event_buffer_low_callback(void *data)
3218 {
3219     logf("low buffer callback");
3220     LOGFQUEUE("buffering > audio Q_AUDIO_BUFFERING: buffer low");
3221     audio_queue_post(Q_AUDIO_BUFFERING, BUFFER_EVENT_BUFFER_LOW);
3222     (void)data;
3223 }
3224
3225 /* Called when handles must be discarded in order to buffer new data */
3226 static void buffer_event_rebuffer_callback(void *data)
3227 {
3228     logf("rebuffer callback");
3229     LOGFQUEUE("buffering > audio Q_AUDIO_BUFFERING: rebuffer");
3230     audio_queue_post(Q_AUDIO_BUFFERING, BUFFER_EVENT_REBUFFER);
3231     (void)data;
3232 }
3233
3234 /* A handle has completed buffering and all required data is available */
3235 static void buffer_event_finished_callback(void *data)
3236 {
3237     int hid = *(const int *)data;
3238     const enum data_type htype = buf_handle_data_type(hid);
3239
3240     logf("handle %d finished buffering (type:%u)", hid, (unsigned)htype);
3241
3242     /* Limit queue traffic */
3243     switch (htype)
3244     {
3245     case TYPE_ID3:
3246         /* The metadata handle for the last loaded track has been buffered.
3247            We can ask the audio thread to load the rest of the track's data. */
3248         LOGFQUEUE("buffering > audio Q_AUDIO_FINISH_LOAD_TRACK: %d", hid);
3249         audio_queue_post(Q_AUDIO_FINISH_LOAD_TRACK, hid);
3250         break;
3251
3252     case TYPE_PACKET_AUDIO:
3253         /* Strip any useless trailing tags that are left. */
3254         strip_tags(hid);
3255         /* Fall-through */
3256     case TYPE_ATOMIC_AUDIO:
3257         LOGFQUEUE("buffering > audio Q_AUDIO_HANDLE_FINISHED: %d", hid);
3258         audio_queue_post(Q_AUDIO_HANDLE_FINISHED, hid);
3259         break;
3260
3261     default:
3262         /* Don't care to know about these */
3263         break;
3264     }
3265 }
3266
3267
3268 /** -- Codec callbacks -- **/
3269
3270 /* Update elapsed time for next PCM insert */
3271 void audio_codec_update_elapsed(unsigned long elapsed)
3272 {
3273 #ifdef AB_REPEAT_ENABLE
3274     ab_position_report(elapsed);
3275 #endif
3276     /* Save in codec's id3 where it is used at next pcm insert */
3277     id3_get(CODEC_ID3)->elapsed = elapsed;
3278 }
3279
3280 /* Update offset for next PCM insert */
3281 void audio_codec_update_offset(size_t offset)
3282 {
3283     /* Save in codec's id3 where it is used at next pcm insert */
3284     id3_get(CODEC_ID3)->offset = offset;
3285 }
3286
3287 /* Codec has finished running */
3288 void audio_codec_complete(int status)
3289 {
3290 #ifdef AB_REPEAT_ENABLE
3291     if (status >= CODEC_OK)
3292     {
3293         /* Normal automatic skip */
3294         ab_end_of_track_report();
3295     }
3296 #endif
3297
3298     LOGFQUEUE("codec > audio Q_AUDIO_CODEC_COMPLETE: %d", status);
3299     audio_queue_post(Q_AUDIO_CODEC_COMPLETE, status);
3300 }
3301
3302 /* Codec has finished seeking */
3303 void audio_codec_seek_complete(void)
3304 {
3305     LOGFQUEUE("codec > audio Q_AUDIO_CODEC_SEEK_COMPLETE");
3306     audio_queue_post(Q_AUDIO_CODEC_SEEK_COMPLETE, 0);
3307 }
3308
3309
3310 /** --- Pcmbuf callbacks --- **/
3311
3312 /* Update the elapsed and offset from the information cached during the
3313    PCM buffer insert */
3314 void audio_pcmbuf_position_callback(unsigned long elapsed, off_t offset,
3315                                     unsigned int key)
3316 {
3317     if (key == position_key)
3318     {
3319         struct mp3entry *id3 = id3_get(PLAYING_ID3);
3320         id3->elapsed = elapsed;
3321         id3->offset = offset;
3322     }
3323 }
3324
3325 /* Synchronize position info to the codec's */
3326 void audio_pcmbuf_sync_position(void)
3327 {
3328     audio_pcmbuf_position_callback(ci.id3->elapsed, ci.id3->offset,
3329                                    pcmbuf_get_position_key());
3330 }
3331
3332 /* Post message from pcmbuf that the end of the previous track has just
3333  * been played */
3334 void audio_pcmbuf_track_change(bool pcmbuf)
3335 {
3336     if (pcmbuf)
3337     {
3338         /* Notify of the change in special-purpose semaphore object */
3339         LOGFQUEUE("pcmbuf > pcmbuf Q_AUDIO_TRACK_CHANGED");
3340         audio_pcmbuf_track_change_post();
3341     }
3342     else
3343     {
3344         /* Safe to post directly to the queue */
3345         LOGFQUEUE("pcmbuf > audio Q_AUDIO_TRACK_CHANGED");
3346         audio_queue_post(Q_AUDIO_TRACK_CHANGED, 0);
3347     }
3348 }
3349
3350 /* May pcmbuf start PCM playback when the buffer is full enough? */
3351 bool audio_pcmbuf_may_play(void)
3352 {
3353     return play_status == PLAY_PLAYING && !ff_rw_mode;
3354 }
3355
3356
3357 /** -- External interfaces -- **/
3358
3359 /* Return the playback and recording status */
3360 int audio_status(void)
3361 {
3362     unsigned int ret = play_status;
3363
3364 #ifdef AUDIO_HAVE_RECORDING
3365     /* Do this here for constitency with mpeg.c version */
3366     ret |= pcm_rec_status();
3367 #endif
3368
3369     return (int)ret;
3370 }
3371
3372 /* Clear all accumulated audio errors for playback and recording */
3373 void audio_error_clear(void)
3374 {
3375 #ifdef AUDIO_HAVE_RECORDING
3376     pcm_rec_error_clear();
3377 #endif
3378 }
3379
3380 /* Get a copy of the id3 data for the for current track + offset + skip delta */
3381 bool audio_peek_track(struct mp3entry *id3, int offset)
3382 {
3383     bool retval = false;
3384
3385     id3_mutex_lock();
3386
3387     if (play_status != PLAY_STOPPED)
3388     {
3389         id3->path[0] = '\0'; /* Null path means it should be filled now */
3390         retval = audio_get_track_metadata(offset + skip_offset, id3) &&
3391                 id3->path[0] != '\0';
3392     }
3393
3394     id3_mutex_unlock();
3395
3396     return retval;
3397 }
3398
3399 /* Return the mp3entry for the currently playing track */
3400 struct mp3entry * audio_current_track(void)
3401 {
3402     struct mp3entry *id3;
3403
3404     id3_mutex_lock();
3405
3406 #ifdef AUDIO_FAST_SKIP_PREVIEW
3407     if (skip_offset != 0)
3408     {
3409         /* This is a peekahead */
3410         id3 = id3_get(PLAYING_PEEK_ID3);
3411         audio_peek_track(id3, 0);
3412     }
3413     else
3414 #endif
3415     {
3416         /* Normal case */
3417         id3 = id3_get(PLAYING_ID3);
3418         audio_get_track_metadata(0, id3);
3419     }
3420
3421     id3_mutex_unlock();
3422
3423     return id3;
3424 }
3425
3426 /* Obtains the mp3entry for the next track from the current */
3427 struct mp3entry * audio_next_track(void)
3428 {
3429     struct mp3entry *id3 = id3_get(NEXTTRACK_ID3);
3430
3431     id3_mutex_lock();
3432
3433 #ifdef AUDIO_FAST_SKIP_PREVIEW
3434     if (skip_offset != 0)
3435     {
3436         /* This is a peekahead */
3437         if (!audio_peek_track(id3, 1))
3438             id3 = NULL;
3439     }
3440     else
3441 #endif
3442     {
3443         /* Normal case */
3444         if (!audio_get_track_metadata(1, id3))
3445             id3 = NULL;
3446     }
3447
3448     id3_mutex_unlock();
3449
3450     return id3;
3451 }
3452
3453 /* Start playback at the specified offset */
3454 void audio_play(long offset)
3455 {
3456     logf("audio_play");
3457
3458 #ifdef PLAYBACK_VOICE
3459     /* Truncate any existing voice output so we don't have spelling
3460      * etc. over the first part of the played track */
3461     talk_force_shutup();
3462 #endif
3463
3464     LOGFQUEUE("audio >| audio Q_AUDIO_PLAY: %ld", offset);
3465     audio_queue_send(Q_AUDIO_PLAY, offset);
3466 }
3467
3468 /* Stop playback if playing */
3469 void audio_stop(void)
3470 {
3471     LOGFQUEUE("audio >| audio Q_AUDIO_STOP");
3472     audio_queue_send(Q_AUDIO_STOP, 0);
3473 }
3474
3475 /* Pause playback if playing */
3476 void audio_pause(void)
3477 {
3478     LOGFQUEUE("audio >| audio Q_AUDIO_PAUSE");
3479     audio_queue_send(Q_AUDIO_PAUSE, true);
3480 }
3481
3482 /* This sends a stop message and the audio thread will dump all its
3483    subsequent messages */
3484 void audio_hard_stop(void)
3485 {
3486     /* Stop playback */
3487     LOGFQUEUE("audio >| audio Q_AUDIO_STOP: 1");
3488     audio_queue_send(Q_AUDIO_STOP, 1);
3489 #ifdef PLAYBACK_VOICE
3490     voice_stop();
3491 #endif
3492     if (audiobuf_handle > 0)
3493         audiobuf_handle = core_free(audiobuf_handle);
3494 }
3495
3496 /* Resume playback if paused */
3497 void audio_resume(void)
3498 {
3499     LOGFQUEUE("audio >| audio Q_AUDIO_PAUSE resume");
3500     audio_queue_send(Q_AUDIO_PAUSE, false);
3501 }
3502
3503 /* Skip the specified number of tracks forward or backward from the current */
3504 void audio_skip(int offset)
3505 {
3506     id3_mutex_lock();
3507
3508     /* If offset has to be backed-out to stay in range, no skip is done */
3509     int accum = skip_offset + offset;
3510
3511     while (offset != 0 && !playlist_check(accum))
3512     {
3513         offset += offset < 0 ? 1 : -1;
3514         accum = skip_offset + offset;
3515     }
3516
3517     if (offset != 0)
3518     {
3519         /* Accumulate net manual skip count since the audio thread last
3520            processed one */
3521         skip_offset = accum;
3522
3523         system_sound_play(SOUND_TRACK_SKIP);
3524
3525         LOGFQUEUE("audio > audio Q_AUDIO_SKIP %d", offset);
3526
3527 #ifdef AUDIO_FAST_SKIP_PREVIEW
3528         /* Do this before posting so that the audio thread can correct us
3529            when things settle down - additionally, if audio gets a message
3530            and the delta is zero, the Q_AUDIO_SKIP handler (audio_on_skip)
3531            handler a skip event with the correct info but doesn't skip */
3532         send_event(PLAYBACK_EVENT_TRACK_SKIP, NULL);
3533 #endif /* AUDIO_FAST_SKIP_PREVIEW */
3534
3535         /* Playback only needs the final state even if more than one is
3536            processed because it wasn't removed in time */
3537         queue_remove_from_head(&audio_queue, Q_AUDIO_SKIP);
3538         audio_queue_post(Q_AUDIO_SKIP, 0);
3539     }
3540     else
3541     {
3542         /* No more tracks */
3543         system_sound_play(SOUND_TRACK_NO_MORE);
3544     }
3545
3546     id3_mutex_unlock();
3547 }
3548
3549 /* Skip one track forward from the current */
3550 void audio_next(void)
3551 {
3552     audio_skip(1);
3553 }
3554
3555 /* Skip one track backward from the current */
3556 void audio_prev(void)
3557 {
3558     audio_skip(-1);
3559 }
3560
3561 /* Move one directory forward */
3562 void audio_next_dir(void)
3563 {
3564     LOGFQUEUE("audio > audio Q_AUDIO_DIR_SKIP 1");
3565     audio_queue_post(Q_AUDIO_DIR_SKIP, 1);
3566 }
3567
3568 /* Move one directory backward */
3569 void audio_prev_dir(void)
3570 {
3571     LOGFQUEUE("audio > audio Q_AUDIO_DIR_SKIP -1");
3572     audio_queue_post(Q_AUDIO_DIR_SKIP, -1);
3573 }
3574
3575 /* Pause playback in order to start a seek that flushes the old audio */
3576 void audio_pre_ff_rewind(void)
3577 {
3578     LOGFQUEUE("audio > audio Q_AUDIO_PRE_FF_REWIND");
3579     audio_queue_post(Q_AUDIO_PRE_FF_REWIND, 0);
3580 }
3581
3582 /* Seek to the new time in the current track */
3583 void audio_ff_rewind(long time)
3584 {
3585     LOGFQUEUE("audio > audio Q_AUDIO_FF_REWIND");
3586     audio_queue_post(Q_AUDIO_FF_REWIND, time);
3587 }
3588
3589 /* Clear all but the currently playing track then rebuffer */
3590 void audio_flush_and_reload_tracks(void)
3591 {
3592     LOGFQUEUE("audio > audio Q_AUDIO_FLUSH");
3593     audio_queue_post(Q_AUDIO_FLUSH, 0);
3594 }
3595
3596 /* Return the pointer to the main audio buffer, optionally preserving
3597    voicing */
3598 unsigned char * audio_get_buffer(bool talk_buf, size_t *buffer_size)
3599 {
3600     unsigned char *buf;
3601
3602     if (audio_is_initialized)
3603     {
3604         audio_hard_stop();
3605     }
3606     /* else buffer_state will be AUDIOBUF_STATE_TRASHED at this point */
3607
3608     if (buffer_size == NULL)
3609     {
3610         /* Special case for talk_init to use since it already knows it's
3611            trashed */
3612         buffer_state = AUDIOBUF_STATE_TRASHED;
3613         return NULL;
3614     }
3615
3616     /* make sure buffer is freed and re-allocated to simplify code below
3617      * (audio_hard_stop() likely has done that already) */
3618     if (audiobuf_handle > 0)
3619         audiobuf_handle = core_free(audiobuf_handle);
3620
3621     audiobuf_handle = core_alloc_maximum("audiobuf", &filebuflen, &ops);
3622     buf = core_get_data(audiobuf_handle);
3623
3624     if (buffer_state == AUDIOBUF_STATE_INITIALIZED)
3625         buffering_reset(NULL, 0); /* mark buffer invalid */
3626
3627     if (talk_buf || !talk_voice_required())
3628     {
3629         logf("get buffer: talk, audio");
3630         /* Ok to use everything from audiobuf - voice is loaded,
3631            the talk buffer is not needed because voice isn't being used, or
3632            could be AUDIOBUF_STATE_TRASHED already. If state is
3633            AUDIOBUF_STATE_VOICED_ONLY, no problem as long as memory isn't
3634            written without the caller knowing what's going on. Changing certain
3635            settings may move it to a worse condition but the memory in use by
3636            something else will remain undisturbed.
3637          */
3638         if (buffer_state != AUDIOBUF_STATE_TRASHED)
3639         {
3640             talk_buffer_steal();
3641             buffer_state = AUDIOBUF_STATE_TRASHED;
3642         }
3643     }
3644     else
3645     {
3646         logf("get buffer: audio");
3647         /* Safe to just return this if already AUDIOBUF_STATE_VOICED_ONLY or
3648            still AUDIOBUF_STATE_INITIALIZED */
3649         size_t talkbuf_size = talkbuf_init(buf);
3650         buf += talkbuf_size; /* Skip talk buffer */
3651         filebuflen -= talkbuf_size;
3652         buffer_state = AUDIOBUF_STATE_VOICED_ONLY;
3653     }
3654
3655     *buffer_size = filebuflen;
3656     return buf;
3657 }
3658
3659 #ifdef HAVE_RECORDING
3660 /* Stop audio, voice and obtain all available buffer space */
3661 unsigned char * audio_get_recording_buffer(size_t *buffer_size)
3662 {
3663     audio_hard_stop();
3664     return audio_get_buffer(true, buffer_size);
3665 }
3666 #endif /* HAVE_RECORDING */
3667
3668 /* Restore audio buffer to a particular state (promoting status) */
3669 bool audio_restore_playback(int type)
3670 {
3671     switch (type)
3672     {
3673     case AUDIO_WANT_PLAYBACK:
3674         if (buffer_state != AUDIOBUF_STATE_INITIALIZED)
3675             audio_reset_buffer(AUDIOBUF_STATE_INITIALIZED);
3676         return true;
3677     case AUDIO_WANT_VOICE:
3678         if (buffer_state == AUDIOBUF_STATE_TRASHED)
3679             audio_reset_buffer(AUDIOBUF_STATE_VOICED_ONLY);
3680         return true;
3681     default:
3682         return false;
3683     }
3684 }
3685
3686
3687 /** --- Miscellaneous public interfaces --- **/
3688
3689 #ifdef HAVE_ALBUMART
3690 /* Return which album art handle is current for the user in the given slot */
3691 int playback_current_aa_hid(int slot)
3692 {
3693     if ((unsigned)slot < MAX_MULTIPLE_AA)
3694     {
3695         struct track_info *info = track_list_user_current(skip_offset);
3696
3697         if (!info && abs(skip_offset) <= 1)
3698         {
3699             /* Give the actual position a go */
3700             info = track_list_user_current(0);
3701         }
3702
3703         if (info)
3704             return info->aa_hid[slot];
3705     }
3706
3707     return ERR_HANDLE_NOT_FOUND;
3708 }
3709
3710 /* Find an album art slot that doesn't match the dimensions of another that
3711    is already claimed - increment the use count if it is */
3712 int playback_claim_aa_slot(struct dim *dim)
3713 {
3714     int i;
3715
3716     /* First try to find a slot already having the size to reuse it since we
3717        don't want albumart of the same size buffered multiple times */
3718     FOREACH_ALBUMART(i)
3719     {
3720         struct albumart_slot *slot = &albumart_slots[i];
3721
3722         if (slot->dim.width == dim->width &&
3723             slot->dim.height == dim->height)
3724         {
3725             slot->used++;
3726             return i;
3727         }
3728     }
3729
3730     /* Size is new, find a free slot */
3731     FOREACH_ALBUMART(i)
3732     {
3733         if (!albumart_slots[i].used)
3734         {
3735             albumart_slots[i].used++;
3736             albumart_slots[i].dim = *dim;
3737             return i;
3738         }
3739     }
3740
3741     /* Sorry, no free slot */
3742     return -1;
3743 }
3744
3745 /* Invalidate the albumart_slot - decrement the use count if > 0 */
3746 void playback_release_aa_slot(int slot)
3747 {
3748     if ((unsigned)slot < MAX_MULTIPLE_AA)
3749     {
3750         struct albumart_slot *aa_slot = &albumart_slots[slot];
3751
3752         if (aa_slot->used > 0)
3753             aa_slot->used--;
3754     }
3755 }
3756 #endif /* HAVE_ALBUMART */
3757
3758
3759 #ifdef HAVE_RECORDING
3760 /* Load an encoder and run it */
3761 bool audio_load_encoder(int afmt)
3762 {
3763 #if (CONFIG_PLATFORM & PLATFORM_NATIVE)
3764     LOGFQUEUE("audio >| Q_AUDIO_LOAD_ENCODER: %d", afmt);
3765     return audio_queue_send(Q_AUDIO_LOAD_ENCODER, afmt) != 0;
3766 #else
3767     (void)afmt;
3768     return true;
3769 #endif
3770 }
3771
3772 /* Stop an encoder and unload it */
3773 void audio_remove_encoder(void)
3774 {
3775 #if (CONFIG_PLATFORM & PLATFORM_NATIVE)
3776     LOGFQUEUE("audio >| Q_AUDIO_LOAD_ENCODER: NULL");
3777     audio_queue_send(Q_AUDIO_LOAD_ENCODER, AFMT_UNKNOWN);
3778 #endif
3779 }
3780 #endif /* HAVE_RECORDING */
3781
3782 /* Is an automatic skip in progress? If called outside transition callbacks,
3783    indicates the last skip type at the time it was processed and isn't very
3784    meaningful. */
3785 bool audio_automatic_skip(void)
3786 {
3787     return automatic_skip;
3788 }
3789
3790 /* Would normally calculate byte offset from an elapsed time but is not
3791    used on SWCODEC */
3792 int audio_get_file_pos(void)
3793 {
3794     return 0;
3795 }
3796
3797 /* Return the elapsed time of the track previous to the current */
3798 unsigned long audio_prev_elapsed(void)
3799 {
3800     return prev_track_elapsed;
3801 }
3802
3803 /* Return total file buffer length after accounting for the talk buf */
3804 size_t audio_get_filebuflen(void)
3805 {
3806     return buf_length();
3807 }
3808
3809 /* How many tracks exist on the buffer - full or partial */
3810 int audio_track_count(void)
3811     __attribute__((alias("track_list_count")));
3812
3813 /* Return total ringbuffer space occupied - ridx to widx */
3814 long audio_filebufused(void)
3815 {
3816     return buf_used();
3817 }
3818
3819
3820 /** -- Settings -- **/
3821
3822 /* Enable or disable cuesheet support and allocate/don't allocate the
3823    extra associated resources */
3824 void audio_set_cuesheet(int enable)
3825 {
3826     if (play_status == PLAY_STOPPED || !enable != !get_current_cuesheet())
3827     {
3828         LOGFQUEUE("audio >| audio Q_AUDIO_REMAKE_AUDIO_BUFFER");
3829         audio_queue_send(Q_AUDIO_REMAKE_AUDIO_BUFFER, 0);
3830     }
3831 }
3832
3833 #ifdef HAVE_DISK_STORAGE
3834 /* Set the audio antiskip buffer margin by index */
3835 void audio_set_buffer_margin(int setting)
3836 {
3837     static const unsigned short lookup[] =
3838         { 5, 15, 30, 60, 120, 180, 300, 600 };
3839
3840     if ((unsigned)setting >= ARRAYLEN(lookup))
3841         setting = 0;
3842
3843     logf("buffer margin: %u", (unsigned)lookup[setting]);
3844
3845     LOGFQUEUE("audio > audio Q_AUDIO_UPDATE_WATERMARK: %u",
3846               (unsigned)lookup[setting]);
3847     audio_queue_post(Q_AUDIO_UPDATE_WATERMARK, lookup[setting]);
3848 }
3849 #endif /* HAVE_DISK_STORAGE */
3850
3851 #ifdef HAVE_CROSSFADE
3852 /* Take necessary steps to enable or disable the crossfade setting */
3853 void audio_set_crossfade(int enable)
3854 {
3855     /* Tell it the next setting to use */
3856     pcmbuf_request_crossfade_enable(enable);
3857
3858     /* Return if size hasn't changed or this is too early to determine
3859        which in the second case there's no way we could be playing
3860        anything at all */
3861     if (!pcmbuf_is_same_size())
3862     {
3863         LOGFQUEUE("audio >| audio Q_AUDIO_REMAKE_AUDIO_BUFFER");
3864         audio_queue_send(Q_AUDIO_REMAKE_AUDIO_BUFFER, 0);
3865     }
3866 }
3867 #endif /* HAVE_CROSSFADE */
3868
3869
3870 /** -- Startup -- **/
3871
3872 /* Initialize the audio system - called from init() in main.c */
3873 void audio_init(void)
3874 {
3875     /* Can never do this twice */
3876     if (audio_is_initialized)
3877     {
3878         logf("audio: already initialized");
3879         return;
3880     }
3881
3882     logf("audio: initializing");
3883
3884     /* Initialize queues before giving control elsewhere in case it likes
3885        to send messages. Thread creation will be delayed however so nothing
3886        starts running until ready if something yields such as talk_init. */
3887     queue_init(&audio_queue, true);
3888
3889     mutex_init(&id3_mutex);
3890
3891     pcm_init();
3892
3893     codec_thread_init();
3894
3895     /* This thread does buffer, so match its priority */
3896     audio_thread_id = create_thread(audio_thread, audio_stack,
3897                   sizeof(audio_stack), 0, audio_thread_name
3898                   IF_PRIO(, MIN(PRIORITY_BUFFERING, PRIORITY_USER_INTERFACE))
3899                   IF_COP(, CPU));
3900
3901     queue_enable_queue_send(&audio_queue, &audio_queue_sender_list,
3902                             audio_thread_id);
3903
3904     /* Initialize the track buffering system */
3905     track_list_init();
3906     buffering_init();
3907
3908 #ifdef HAVE_CROSSFADE
3909     /* Set crossfade setting for next buffer init which should be about... */
3910     pcmbuf_request_crossfade_enable(global_settings.crossfade);
3911 #endif
3912
3913     /* ...now...audio_reset_buffer must know the size of voicefile buffer so
3914        init talk first which will init the buffers */
3915     talk_init();
3916
3917     /* Probably safe to say */
3918     audio_is_initialized = true;
3919
3920     sound_settings_apply();
3921 #ifdef HAVE_DISK_STORAGE
3922     audio_set_buffer_margin(global_settings.buffer_margin);
3923 #endif
3924 }