apps/codec_thread.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 #include "config.h"
  23 #include "system.h"
  24 #include "playback.h"
  25 #include "codec_thread.h"
  26 #include "kernel.h"
  27 #include "codecs.h"
  28 #include "buffering.h"
  29 #include "pcmbuf.h"
  30 #include "dsp.h"
  31 #include "abrepeat.h"
  32 #include "metadata.h"
  33 #include "splash.h"
  34
  35 /* Define LOGF_ENABLE to enable logf output in this file */
  36 /*#define LOGF_ENABLE*/
  37 #include "logf.h"
  38
  39 /* macros to enable logf for queues
  40    logging on SYS_TIMEOUT can be disabled */
  41 #ifdef SIMULATOR
  42 /* Define this for logf output of all queuing except SYS_TIMEOUT */
  43 #define PLAYBACK_LOGQUEUES
  44 /* Define this to logf SYS_TIMEOUT messages */
  45 /*#define PLAYBACK_LOGQUEUES_SYS_TIMEOUT*/
  46 #endif
  47
  48 #ifdef PLAYBACK_LOGQUEUES
  49 #define LOGFQUEUE logf
  50 #else
  51 #define LOGFQUEUE(...)
  52 #endif
  53
  54 #ifdef PLAYBACK_LOGQUEUES_SYS_TIMEOUT
  55 #define LOGFQUEUE_SYS_TIMEOUT logf
  56 #else
  57 #define LOGFQUEUE_SYS_TIMEOUT(...)
  58 #endif
  59
  60
  61 /* Variables are commented with the threads that use them:
  62  * A=audio, C=codec, V=voice. A suffix of - indicates that
  63  * the variable is read but not updated on that thread.
  64
  65  * Unless otherwise noted, the extern variables are located
  66  * in playback.c.
  67  */
  68
  69 /* Main state control */
  70
  71 /* Type of codec loaded? (C/A) */
  72 static int current_codectype SHAREDBSS_ATTR = AFMT_UNKNOWN;
  73
  74 extern struct mp3entry *thistrack_id3,  /* the currently playing track */
  75                        *othertrack_id3; /* prev track during track-change-transition, or end of playlist,
  76                                          * next track otherwise */
  77
  78 /* Track change controls */
  79 extern struct event_queue audio_queue SHAREDBSS_ATTR;
  80
  81
  82 extern struct codec_api ci; /* from codecs.c */
  83
  84 /* Codec thread */
  85 static unsigned int codec_thread_id; /* For modifying thread priority later */
  86 static struct event_queue codec_queue SHAREDBSS_ATTR;
  87 static struct queue_sender_list codec_queue_sender_list SHAREDBSS_ATTR;
  88 static long codec_stack[(DEFAULT_STACK_SIZE + 0x2000)/sizeof(long)]
  89                 IBSS_ATTR;
  90 static const char codec_thread_name[] = "codec";
  91
  92 /* static routines */
  93 static void codec_queue_ack(intptr_t ackme)
  94 {
  95     queue_reply(&codec_queue, ackme);
  96 }
  97
  98 static intptr_t codec_queue_send(long id, intptr_t data)
  99 {
 100     return queue_send(&codec_queue, id, data);
 101 }
 102
 103 /**************************************/
 104
 105 /** misc external functions */
 106
 107 /* Used to check whether a new codec must be loaded. See array audio_formats[]
 108  * in metadata.c */
 109 int get_codec_base_type(int type)
 110 {
 111     int base_type = type;
 112     switch (type) {
 113         case AFMT_MPA_L1:
 114         case AFMT_MPA_L2:
 115         case AFMT_MPA_L3:
 116             base_type = AFMT_MPA_L3;
 117             break;
 118         case AFMT_MPC_SV7:
 119         case AFMT_MPC_SV8:
 120             base_type = AFMT_MPC_SV7;
 121             break;
 122         case AFMT_MP4_AAC:
 123         case AFMT_MP4_AAC_HE:
 124             base_type = AFMT_MP4_AAC;
 125             break;
 126         case AFMT_SAP:
 127         case AFMT_CMC:
 128         case AFMT_CM3:
 129         case AFMT_CMR:
 130         case AFMT_CMS:
 131         case AFMT_DMC:
 132         case AFMT_DLT:
 133         case AFMT_MPT:
 134         case AFMT_MPD:
 135         case AFMT_RMT:
 136         case AFMT_TMC:
 137         case AFMT_TM8:
 138         case AFMT_TM2:
 139             base_type = AFMT_SAP;
 140             break;
 141         default:
 142             break;
 143     }
 144
 145     return base_type;
 146 }
 147
 148 const char *get_codec_filename(int cod_spec)
 149 {
 150     const char *fname;
 151
 152 #ifdef HAVE_RECORDING
 153     /* Can choose decoder or encoder if one available */
 154     int type = cod_spec & CODEC_TYPE_MASK;
 155     int afmt = cod_spec & CODEC_AFMT_MASK;
 156
 157     if ((unsigned)afmt >= AFMT_NUM_CODECS)
 158         type = AFMT_UNKNOWN | (type & CODEC_TYPE_MASK);
 159
 160     fname = (type == CODEC_TYPE_ENCODER) ?
 161                 audio_formats[afmt].codec_enc_root_fn :
 162                 audio_formats[afmt].codec_root_fn;
 163
 164     logf("%s: %d - %s",
 165         (type == CODEC_TYPE_ENCODER) ? "Encoder" : "Decoder",
 166         afmt, fname ? fname : "<unknown>");
 167 #else /* !HAVE_RECORDING */
 168     /* Always decoder */
 169     if ((unsigned)cod_spec >= AFMT_NUM_CODECS)
 170         cod_spec = AFMT_UNKNOWN;
 171     fname = audio_formats[cod_spec].codec_root_fn;
 172     logf("Codec: %d - %s",  cod_spec, fname ? fname : "<unknown>");
 173 #endif /* HAVE_RECORDING */
 174
 175     return fname;
 176 } /* get_codec_filename */
 177
 178 /* Borrow the codec thread and return the ID */
 179 void codec_thread_do_callback(void (*fn)(void), unsigned int *id)
 180 {
 181     /* Set id before telling thread to call something; it may be
 182      * needed before this function returns. */
 183     if (id != NULL)
 184         *id = codec_thread_id;
 185
 186     /* Codec thread will signal just before entering callback */
 187     LOGFQUEUE("codec >| Q_CODEC_DO_CALLBACK");
 188     codec_queue_send(Q_CODEC_DO_CALLBACK, (intptr_t)fn);
 189 }
 190
 191
 192 /** codec API callbacks */
 193
 194 static void* codec_get_buffer(size_t *size)
 195 {
 196     ssize_t s = CODEC_SIZE - codec_size;
 197     void *buf = &codecbuf[codec_size];
 198     ALIGN_BUFFER(buf, s, CACHEALIGN_SIZE);
 199
 200     if (s <= 0)
 201         return NULL;
 202
 203     *size = s;
 204     return buf;
 205 }
 206
 207 static void codec_pcmbuf_insert_callback(
 208         const void *ch1, const void *ch2, int count)
 209 {
 210     const char *src[2] = { ch1, ch2 };
 211
 212     while (count > 0)
 213     {
 214         int out_count = dsp_output_count(ci.dsp, count);
 215         int inp_count;
 216         char *dest;
 217
 218         /* Prevent audio from a previous track from playing */
 219         if (ci.new_track || ci.stop_codec)
 220             return;
 221
 222         while ((dest = pcmbuf_request_buffer(&out_count)) == NULL)
 223         {
 224             cancel_cpu_boost();
 225             sleep(1);
 226             if (ci.seek_time || ci.new_track || ci.stop_codec)
 227                 return;
 228         }
 229
 230         /* Get the real input_size for output_size bytes, guarding
 231          * against resampling buffer overflows. */
 232         inp_count = dsp_input_count(ci.dsp, out_count);
 233
 234         if (inp_count <= 0)
 235             return;
 236
 237         /* Input size has grown, no error, just don't write more than length */
 238         if (inp_count > count)
 239             inp_count = count;
 240
 241         out_count = dsp_process(ci.dsp, dest, src, inp_count);
 242
 243         if (out_count <= 0)
 244             return;
 245
 246         pcmbuf_write_complete(out_count);
 247
 248         count -= inp_count;
 249     }
 250 } /* codec_pcmbuf_insert_callback */
 251
 252 static void codec_set_elapsed_callback(unsigned long value)
 253 {
 254     if (ci.seek_time)
 255         return;
 256
 257 #ifdef AB_REPEAT_ENABLE
 258     ab_position_report(value);
 259 #endif
 260
 261     unsigned long latency = pcmbuf_get_latency();
 262     if (value < latency)
 263         thistrack_id3->elapsed = 0;
 264     else
 265     {
 266         unsigned long elapsed = value - latency;
 267         if (elapsed > thistrack_id3->elapsed ||
 268             elapsed < thistrack_id3->elapsed - 2)
 269             {
 270                 thistrack_id3->elapsed = elapsed;
 271             }
 272     }
 273 }
 274
 275 static void codec_set_offset_callback(size_t value)
 276 {
 277     if (ci.seek_time)
 278         return;
 279
 280     unsigned long latency = pcmbuf_get_latency() * thistrack_id3->bitrate / 8;
 281     if (value < latency)
 282         thistrack_id3->offset = 0;
 283     else
 284         thistrack_id3->offset = value - latency;
 285 }
 286
 287 /* helper function, not a callback */
 288 static void codec_advance_buffer_counters(size_t amount)
 289 {
 290     bufadvance(get_audio_hid(), amount);
 291     ci.curpos += amount;
 292 }
 293
 294 /* copy up-to size bytes into ptr and return the actual size copied */
 295 static size_t codec_filebuf_callback(void *ptr, size_t size)
 296 {
 297     ssize_t copy_n;
 298
 299     if (ci.stop_codec)
 300         return 0;
 301
 302     copy_n = bufread(get_audio_hid(), size, ptr);
 303
 304     /* Nothing requested OR nothing left */
 305     if (copy_n == 0)
 306         return 0;
 307
 308     /* Update read and other position pointers */
 309     codec_advance_buffer_counters(copy_n);
 310
 311     /* Return the actual amount of data copied to the buffer */
 312     return copy_n;
 313 } /* codec_filebuf_callback */
 314
 315 static void* codec_request_buffer_callback(size_t *realsize, size_t reqsize)
 316 {
 317     size_t copy_n = reqsize;
 318     ssize_t ret;
 319     void *ptr;
 320
 321     ret = bufgetdata(get_audio_hid(), reqsize, &ptr);
 322     if (ret >= 0)
 323         copy_n = MIN((size_t)ret, reqsize);
 324     else
 325         copy_n = 0;
 326
 327     if (copy_n == 0)
 328         ptr = NULL;
 329
 330     *realsize = copy_n;
 331     return ptr;
 332 } /* codec_request_buffer_callback */
 333
 334 static void codec_advance_buffer_callback(size_t amount)
 335 {
 336     codec_advance_buffer_counters(amount);
 337     codec_set_offset_callback(ci.curpos);
 338 }
 339
 340 static bool codec_seek_buffer_callback(size_t newpos)
 341 {
 342     logf("codec_seek_buffer_callback");
 343
 344     int ret = bufseek(get_audio_hid(), newpos);
 345     if (ret == 0) {
 346         ci.curpos = newpos;
 347         return true;
 348     }
 349     else {
 350         return false;
 351     }
 352 }
 353
 354 static void codec_seek_complete_callback(void)
 355 {
 356     struct queue_event ev;
 357
 358     logf("seek_complete");
 359
 360     /* Clear DSP */
 361     dsp_configure(ci.dsp, DSP_FLUSH, 0);
 362
 363     /* Post notification to audio thread */
 364     LOGFQUEUE("audio > Q_AUDIO_SEEK_COMPLETE");
 365     queue_post(&audio_queue, Q_AUDIO_SEEK_COMPLETE, 0);
 366
 367     /* Wait for ACK */
 368     queue_wait(&codec_queue, &ev);
 369
 370     /* ACK back in context */
 371     codec_queue_ack(Q_AUDIO_SEEK_COMPLETE);
 372 }
 373
 374 static bool codec_request_next_track_callback(void)
 375 {
 376     struct queue_event ev;
 377
 378     logf("Request new track");
 379
 380     audio_set_prev_elapsed(thistrack_id3->elapsed);
 381
 382 #ifdef AB_REPEAT_ENABLE
 383     ab_end_of_track_report();
 384 #endif
 385
 386     if (ci.stop_codec)
 387     {
 388         /* Handle ACK in outer loop */
 389         LOGFQUEUE("codec: already stopping");
 390         return false;
 391     }
 392
 393     trigger_cpu_boost();
 394
 395     /* Post request to audio thread */
 396     LOGFQUEUE("codec > audio Q_AUDIO_CHECK_NEW_TRACK");
 397     queue_post(&audio_queue, Q_AUDIO_CHECK_NEW_TRACK, 0);
 398
 399     /* Wait for ACK */
 400     queue_wait(&codec_queue, &ev);
 401
 402     if (ev.data == Q_CODEC_REQUEST_COMPLETE)
 403     {
 404         /* Seek to the beginning of the new track because if the struct
 405            mp3entry was buffered, "elapsed" might not be zero (if the track has
 406            been played already but not unbuffered) */
 407         codec_seek_buffer_callback(thistrack_id3->first_frame_offset);
 408     }
 409
 410     /* ACK back in context */
 411     codec_queue_ack(Q_AUDIO_CHECK_NEW_TRACK);
 412
 413     if (ev.data != Q_CODEC_REQUEST_COMPLETE || ci.stop_codec)
 414     {
 415         LOGFQUEUE("codec <= request failed (%d)", ev.data);
 416         return false;
 417     }
 418
 419     LOGFQUEUE("codec <= Q_CODEC_REQEST_COMPLETE");
 420     return true;
 421 }
 422
 423 static void codec_configure_callback(int setting, intptr_t value)
 424 {
 425     if (!dsp_configure(ci.dsp, setting, value))
 426         { logf("Illegal key:%d", setting); }
 427 }
 428
 429 /* Initialize codec API */
 430 void codec_init_codec_api(void)
 431 {
 432     ci.dsp                 = (struct dsp_config *)dsp_configure(NULL, DSP_MYDSP,
 433                                                                 CODEC_IDX_AUDIO);
 434     ci.codec_get_buffer    = codec_get_buffer;
 435     ci.pcmbuf_insert       = codec_pcmbuf_insert_callback;
 436     ci.set_elapsed         = codec_set_elapsed_callback;
 437     ci.read_filebuf        = codec_filebuf_callback;
 438     ci.request_buffer      = codec_request_buffer_callback;
 439     ci.advance_buffer      = codec_advance_buffer_callback;
 440     ci.seek_buffer         = codec_seek_buffer_callback;
 441     ci.seek_complete       = codec_seek_complete_callback;
 442     ci.request_next_track  = codec_request_next_track_callback;
 443     ci.set_offset          = codec_set_offset_callback;
 444     ci.configure           = codec_configure_callback;
 445 }
 446
 447
 448 /* track change */
 449
 450 /** CODEC THREAD */
 451 static void codec_thread(void)
 452 {
 453     struct queue_event ev;
 454
 455
 456     while (1)
 457     {
 458         int status = CODEC_OK;
 459         void *handle = NULL;
 460         int hid;
 461         const char *codec_fn;
 462
 463 #ifdef HAVE_CROSSFADE
 464         if (!pcmbuf_is_crossfade_active())
 465 #endif
 466         {
 467             cancel_cpu_boost();
 468         }
 469
 470         queue_wait(&codec_queue, &ev);
 471
 472         switch (ev.id)
 473         {
 474             case Q_CODEC_LOAD_DISK:
 475                 LOGFQUEUE("codec < Q_CODEC_LOAD_DISK");
 476                 codec_fn = get_codec_filename(ev.data);
 477                 if (!codec_fn)
 478                     break;
 479 #ifdef AUDIO_HAVE_RECORDING
 480                 if (ev.data & CODEC_TYPE_ENCODER)
 481                 {
 482                     ev.id = Q_ENCODER_LOAD_DISK;
 483                     handle = codec_load_file(codec_fn, &ci);
 484                     if (handle)
 485                         codec_queue_ack(Q_ENCODER_LOAD_DISK);
 486                 }
 487                 else
 488 #endif
 489                 {
 490                     codec_queue_ack(Q_CODEC_LOAD_DISK);
 491                     handle = codec_load_file(codec_fn, &ci);
 492                 }
 493                 break;
 494
 495             case Q_CODEC_LOAD:
 496                 LOGFQUEUE("codec < Q_CODEC_LOAD");
 497                 codec_queue_ack(Q_CODEC_LOAD);
 498                 hid = (int)ev.data;
 499                 handle = codec_load_buf(hid, &ci);
 500                 bufclose(hid);
 501                 break;
 502
 503             case Q_CODEC_DO_CALLBACK:
 504                 LOGFQUEUE("codec < Q_CODEC_DO_CALLBACK");
 505                 codec_queue_ack(Q_CODEC_DO_CALLBACK);
 506                 if ((void*)ev.data != NULL)
 507                 {
 508                     cpucache_commit_discard();
 509                     ((void (*)(void))ev.data)();
 510                     cpucache_commit();
 511                 }
 512                 break;
 513
 514             default:
 515                 LOGFQUEUE("codec < default : %ld", ev.id);
 516         }
 517
 518         if (handle)
 519         {
 520             /* Codec loaded - call the entrypoint */
 521             yield();
 522             logf("codec running");
 523             status = codec_begin(handle);
 524             logf("codec stopped");
 525             codec_close(handle);
 526             current_codectype = AFMT_UNKNOWN;
 527
 528             if (ci.stop_codec)
 529                 status = CODEC_OK;
 530         }
 531
 532         switch (ev.id)
 533         {
 534 #ifdef AUDIO_HAVE_RECORDING
 535             case Q_ENCODER_LOAD_DISK:
 536 #endif
 537             case Q_CODEC_LOAD_DISK:
 538             case Q_CODEC_LOAD:
 539                 /* Notify about the status */
 540                 if (!handle)
 541                     status = CODEC_ERROR;
 542                 LOGFQUEUE("codec > audio notify status: %d", status);
 543                 queue_post(&audio_queue, ev.id, status);
 544                 break;
 545         }
 546     }
 547 }
 548
 549 void make_codec_thread(void)
 550 {
 551     queue_init(&codec_queue, false);
 552     codec_thread_id = create_thread(
 553             codec_thread, codec_stack, sizeof(codec_stack),
 554             CREATE_THREAD_FROZEN,
 555             codec_thread_name IF_PRIO(, PRIORITY_PLAYBACK)
 556             IF_COP(, CPU));
 557     queue_enable_queue_send(&codec_queue, &codec_queue_sender_list,
 558                             codec_thread_id);
 559 }
 560
 561 void codec_thread_resume(void)
 562 {
 563     thread_thaw(codec_thread_id);
 564 }
 565
 566 bool is_codec_thread(void)
 567 {
 568     return thread_self() == codec_thread_id;
 569 }
 570
 571 #ifdef HAVE_PRIORITY_SCHEDULING
 572 int codec_thread_get_priority(void)
 573 {
 574     return thread_get_priority(codec_thread_id);
 575 }
 576
 577 int codec_thread_set_priority(int priority)
 578 {
 579     return thread_set_priority(codec_thread_id, priority);
 580 }
 581 #endif /* HAVE_PRIORITY_SCHEDULING */
 582
 583 /* functions for audio thread use */
 584 intptr_t codec_ack_msg(intptr_t data, bool stop_codec)
 585 {
 586     intptr_t resp;
 587     LOGFQUEUE("codec >| Q_CODEC_ACK: %d", data);
 588     if (stop_codec)
 589         ci.stop_codec = true;
 590     resp = codec_queue_send(Q_CODEC_ACK, data);
 591     if (stop_codec)
 592         codec_stop();
 593     LOGFQUEUE("  ack: %ld", resp);
 594     return resp;
 595 }
 596
 597 bool codec_load(int hid, int cod_spec)
 598 {
 599     bool retval = false;
 600
 601     ci.stop_codec = false;
 602     current_codectype = cod_spec;
 603
 604     if (hid >= 0)
 605     {
 606         LOGFQUEUE("audio >| codec Q_CODEC_LOAD: %d", hid);
 607         retval = codec_queue_send(Q_CODEC_LOAD, hid) != Q_NULL;
 608     }
 609     else
 610     {
 611         LOGFQUEUE("audio >| codec Q_CODEC_LOAD_DISK: %d", cod_spec);
 612         retval = codec_queue_send(Q_CODEC_LOAD_DISK, cod_spec) != Q_NULL;
 613     }
 614
 615     if (!retval)
 616     {
 617         ci.stop_codec = true;
 618         current_codectype = AFMT_UNKNOWN;
 619     }
 620
 621     return retval;
 622 }
 623
 624 void codec_stop(void)
 625 {
 626     ci.stop_codec = true;
 627     /* Wait until it's in the main loop */
 628     while (codec_ack_msg(0, false) != Q_NULL);
 629     current_codectype = AFMT_UNKNOWN;
 630 }
 631
 632 int codec_loaded(void)
 633 {
 634     return current_codectype;
 635 }