apps/playback.c

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