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  * Copyright (C) 2011      Michael Sevakis
  13  *
  14  * This program is free software; you can redistribute it and/or
  15  * modify it under the terms of the GNU General Public License
  16  * as published by the Free Software Foundation; either version 2
  17  * of the License, or (at your option) any later version.
  18  *
  19  * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY
  20  * KIND, either express or implied.
  21  *
  22  ****************************************************************************/
  23 #include "config.h"
  24 #include "system.h"
  25 #include "kernel.h"
  26 #include "codecs.h"
  27 #include "codec_thread.h"
  28 #include "pcmbuf.h"
  29 #include "playback.h"
  30 #include "buffering.h"
  31 #include "dsp.h"
  32 #include "metadata.h"
  33
  34 /* Define LOGF_ENABLE to enable logf output in this file */
  35 /*#define LOGF_ENABLE*/
  36 #include "logf.h"
  37
  38 /* macros to enable logf for queues
  39    logging on SYS_TIMEOUT can be disabled */
  40 #ifdef SIMULATOR
  41 /* Define this for logf output of all queuing except SYS_TIMEOUT */
  42 #define PLAYBACK_LOGQUEUES
  43 /* Define this to logf SYS_TIMEOUT messages */
  44 /*#define PLAYBACK_LOGQUEUES_SYS_TIMEOUT*/
  45 #endif
  46
  47 #ifdef PLAYBACK_LOGQUEUES
  48 #define LOGFQUEUE logf
  49 #else
  50 #define LOGFQUEUE(...)
  51 #endif
  52
  53 #ifdef PLAYBACK_LOGQUEUES_SYS_TIMEOUT
  54 #define LOGFQUEUE_SYS_TIMEOUT logf
  55 #else
  56 #define LOGFQUEUE_SYS_TIMEOUT(...)
  57 #endif
  58
  59 /* Variables are commented with the threads that use them:
  60  * A=audio, C=codec
  61  * - = reads only
  62  *
  63  * Unless otherwise noted, the extern variables are located
  64  * in playback.c.
  65  */
  66
  67 /* Q_LOAD_CODEC parameter data */
  68 struct codec_load_info
  69 {
  70     int hid;    /* audio handle id (specify < 0 to use afmt) */
  71     int afmt;   /* codec specification (AFMT_*) */
  72 };
  73
  74
  75 /** --- Main state control --- **/
  76
  77 static int codec_type = AFMT_UNKNOWN; /* Codec type (C,A-) */
  78
  79 /* Private interfaces to main playback control */
  80 extern void audio_codec_update_elapsed(unsigned long value);
  81 extern void audio_codec_update_offset(size_t value);
  82 extern void audio_queue_post(long id, intptr_t data);
  83 extern struct codec_api ci; /* from codecs.c */
  84
  85 /* Codec thread */
  86 static unsigned int codec_thread_id; /* For modifying thread priority later */
  87 static struct event_queue codec_queue SHAREDBSS_ATTR;
  88 static struct queue_sender_list codec_queue_sender_list SHAREDBSS_ATTR;
  89 static long codec_stack[(DEFAULT_STACK_SIZE + 0x2000)/sizeof(long)] IBSS_ATTR;
  90 static const char codec_thread_name[] = "codec";
  91
  92 static void unload_codec(void);
  93
  94 /* Messages are only ever sent one at a time to the codec from the audio
  95    thread. This is important for correct operation unless playback is
  96    stopped. */
  97
  98 /* static routines */
  99 static void codec_queue_ack(intptr_t ackme)
 100 {
 101     queue_reply(&codec_queue, ackme);
 102 }
 103
 104 static intptr_t codec_queue_send(long id, intptr_t data)
 105 {
 106     return queue_send(&codec_queue, id, data);
 107 }
 108
 109 /* Poll the state of the codec queue. Returns < 0 if the message is urgent
 110    and any state should exit, > 0 if it's a run message (and it was
 111    scrubbed), 0 if message was ignored. */
 112 static int codec_check_queue__have_msg(void)
 113 {
 114     struct queue_event ev;
 115
 116     queue_peek(&codec_queue, &ev);
 117
 118     /* Seek, pause or stop? Just peek and return if so. Codec
 119        must handle the command after returing. Inserts will not
 120        be allowed until it complies. */
 121     switch (ev.id)
 122     {
 123     case Q_CODEC_SEEK:
 124         LOGFQUEUE("codec - Q_CODEC_SEEK", ev.id);
 125         return -1;
 126     case Q_CODEC_PAUSE:
 127         LOGFQUEUE("codec - Q_CODEC_PAUSE", ev.id);
 128         return -1;
 129     case Q_CODEC_STOP:
 130         LOGFQUEUE("codec - Q_CODEC_STOP", ev.id);
 131         return -1;
 132     }
 133
 134     /* This is in error in this context unless it's "go, go, go!" */
 135     queue_wait(&codec_queue, &ev);
 136
 137     if (ev.id == Q_CODEC_RUN)
 138     {
 139         logf("codec < Q_CODEC_RUN: already running!");
 140         codec_queue_ack(Q_CODEC_RUN);
 141         return 1;
 142     }
 143
 144     /* Ignore it */
 145     logf("codec < bad req %ld (%s)", ev.id, __func__);
 146     codec_queue_ack(Q_NULL);
 147     return 0;
 148 }
 149
 150 /* Does the audio format type equal CODEC_TYPE_ENCODER? */
 151 static inline bool type_is_encoder(int afmt)
 152 {
 153 #ifdef AUDIO_HAVE_RECORDING
 154     return (afmt & CODEC_TYPE_MASK) == CODEC_TYPE_ENCODER;
 155 #else
 156     return false;
 157     (void)afmt;
 158 #endif
 159 }
 160
 161 /**************************************/
 162
 163
 164 /** --- Miscellaneous external functions --- **/
 165 const char * get_codec_filename(int cod_spec)
 166 {
 167     const char *fname;
 168
 169 #ifdef HAVE_RECORDING
 170     /* Can choose decoder or encoder if one available */
 171     int type = cod_spec & CODEC_TYPE_MASK;
 172     int afmt = cod_spec & CODEC_AFMT_MASK;
 173
 174     if ((unsigned)afmt >= AFMT_NUM_CODECS)
 175         type = AFMT_UNKNOWN | (type & CODEC_TYPE_MASK);
 176
 177     fname = (type == CODEC_TYPE_ENCODER) ?
 178                 audio_formats[afmt].codec_enc_root_fn :
 179                 audio_formats[afmt].codec_root_fn;
 180
 181     logf("%s: %d - %s",
 182         (type == CODEC_TYPE_ENCODER) ? "Encoder" : "Decoder",
 183         afmt, fname ? fname : "<unknown>");
 184 #else /* !HAVE_RECORDING */
 185     /* Always decoder */
 186     if ((unsigned)cod_spec >= AFMT_NUM_CODECS)
 187         cod_spec = AFMT_UNKNOWN;
 188     fname = audio_formats[cod_spec].codec_root_fn;
 189     logf("Codec: %d - %s",  cod_spec, fname ? fname : "<unknown>");
 190 #endif /* HAVE_RECORDING */
 191
 192     return fname;
 193 }
 194
 195 /* Borrow the codec thread and return the ID */
 196 void codec_thread_do_callback(void (*fn)(void), unsigned int *id)
 197 {
 198     /* Set id before telling thread to call something; it may be
 199      * needed before this function returns. */
 200     if (id != NULL)
 201         *id = codec_thread_id;
 202
 203     /* Codec thread will signal just before entering callback */
 204     LOGFQUEUE("codec >| Q_CODEC_DO_CALLBACK");
 205     codec_queue_send(Q_CODEC_DO_CALLBACK, (intptr_t)fn);
 206 }
 207
 208
 209 /** --- codec API callbacks --- **/
 210
 211 static void codec_pcmbuf_insert_callback(
 212         const void *ch1, const void *ch2, int count)
 213 {
 214     const char *src[2] = { ch1, ch2 };
 215
 216     while (count > 0)
 217     {
 218         int out_count = dsp_output_count(ci.dsp, count);
 219         int inp_count;
 220         char *dest;
 221
 222         while (1)
 223         {
 224             if ((dest = pcmbuf_request_buffer(&out_count)) != NULL)
 225                 break;
 226
 227             cancel_cpu_boost();
 228
 229             /* It will be awhile before space is available but we want
 230                "instant" response to any message */
 231             queue_wait_w_tmo(&codec_queue, NULL, HZ/20);
 232
 233             if (!queue_empty(&codec_queue) &&
 234                 codec_check_queue__have_msg() < 0)
 235                 return;
 236         }
 237
 238         /* Get the real input_size for output_size bytes, guarding
 239          * against resampling buffer overflows. */
 240         inp_count = dsp_input_count(ci.dsp, out_count);
 241
 242         if (inp_count <= 0)
 243             return;
 244
 245         /* Input size has grown, no error, just don't write more than length */
 246         if (inp_count > count)
 247             inp_count = count;
 248
 249         out_count = dsp_process(ci.dsp, dest, src, inp_count);
 250
 251         if (out_count <= 0)
 252             return;
 253
 254         pcmbuf_write_complete(out_count);
 255
 256         count -= inp_count;
 257     }
 258 }
 259
 260 /* helper function, not a callback */
 261 static bool codec_advance_buffer_counters(size_t amount)
 262 {
 263     if (bufadvance(ci.audio_hid, amount) < 0)
 264     {
 265         ci.curpos = ci.filesize;
 266         return false;
 267     }
 268
 269     ci.curpos += amount;
 270     return true;
 271 }
 272
 273 /* copy up-to size bytes into ptr and return the actual size copied */
 274 static size_t codec_filebuf_callback(void *ptr, size_t size)
 275 {
 276     ssize_t copy_n = bufread(ci.audio_hid, size, ptr);
 277
 278     /* Nothing requested OR nothing left */
 279     if (copy_n <= 0)
 280         return 0;
 281
 282     /* Update read and other position pointers */
 283     codec_advance_buffer_counters(copy_n);
 284
 285     /* Return the actual amount of data copied to the buffer */
 286     return copy_n;
 287 }
 288
 289 static void * codec_request_buffer_callback(size_t *realsize, size_t reqsize)
 290 {
 291     size_t copy_n = reqsize;
 292     ssize_t ret;
 293     void *ptr;
 294
 295     ret = bufgetdata(ci.audio_hid, reqsize, &ptr);
 296     if (ret >= 0)
 297         copy_n = MIN((size_t)ret, reqsize);
 298     else
 299         copy_n = 0;
 300
 301     if (copy_n == 0)
 302         ptr = NULL;
 303
 304     *realsize = copy_n;
 305     return ptr;
 306 }
 307
 308 static void codec_advance_buffer_callback(size_t amount)
 309 {
 310     if (!codec_advance_buffer_counters(amount))
 311         return;
 312
 313     audio_codec_update_offset(ci.curpos);
 314 }
 315
 316 static bool codec_seek_buffer_callback(size_t newpos)
 317 {
 318     logf("codec_seek_buffer_callback");
 319
 320     int ret = bufseek(ci.audio_hid, newpos);
 321     if (ret == 0)
 322     {
 323         ci.curpos = newpos;
 324         return true;
 325     }
 326
 327     return false;
 328 }
 329
 330 static void codec_seek_complete_callback(void)
 331 {
 332     logf("seek_complete");
 333
 334     /* Clear DSP */
 335     dsp_configure(ci.dsp, DSP_FLUSH, 0);
 336
 337     /* Post notification to audio thread */
 338     LOGFQUEUE("audio > Q_AUDIO_CODEC_SEEK_COMPLETE");
 339     audio_queue_post(Q_AUDIO_CODEC_SEEK_COMPLETE, 0);
 340
 341     /* Wait for urgent or go message */
 342     do
 343     {
 344         queue_wait(&codec_queue, NULL);
 345     }
 346     while (codec_check_queue__have_msg() == 0);
 347 }
 348
 349 static void codec_configure_callback(int setting, intptr_t value)
 350 {
 351     if (!dsp_configure(ci.dsp, setting, value))
 352     {
 353         logf("Illegal key: %d", setting);
 354     }
 355 }
 356
 357 static enum codec_command_action
 358     codec_get_command_callback(intptr_t *param)
 359 {
 360     yield();
 361
 362     if (LIKELY(queue_empty(&codec_queue)))
 363         return CODEC_ACTION_NULL; /* As you were */
 364
 365     /* Process the message - return requested action and data (if any should
 366        be expected) */
 367     while (1)
 368     {
 369         enum codec_command_action action = CODEC_ACTION_NULL;
 370         struct queue_event ev;
 371         queue_wait(&codec_queue, &ev);
 372
 373         switch (ev.id)
 374         {
 375         case Q_CODEC_RUN:   /* Already running */
 376             LOGFQUEUE("codec < Q_CODEC_RUN");
 377             break;
 378
 379         case Q_CODEC_PAUSE: /* Stay here and wait */
 380             LOGFQUEUE("codec < Q_CODEC_PAUSE");
 381             codec_queue_ack(Q_CODEC_PAUSE);
 382             continue;
 383
 384         case Q_CODEC_SEEK:  /* Audio wants codec to seek */
 385             LOGFQUEUE("codec < Q_CODEC_SEEK %ld", ev.data);
 386             *param = ev.data;
 387             action = CODEC_ACTION_SEEK_TIME;
 388             break;
 389
 390         case Q_CODEC_STOP:  /* Must only return 0 in main loop */
 391             LOGFQUEUE("codec < Q_CODEC_STOP");
 392             action = CODEC_ACTION_HALT;
 393             break;
 394
 395         default:            /* This is in error in this context. */
 396             ev.id = Q_NULL;
 397             logf("codec bad req %ld (%s)", ev.id, __func__);
 398         }
 399
 400         codec_queue_ack(ev.id);
 401         return action;
 402     }
 403 }
 404
 405 /* Initialize codec API */
 406 void codec_init_codec_api(void)
 407 {
 408     ci.dsp                 = (struct dsp_config *)dsp_configure(NULL, DSP_MYDSP,
 409                                                                 CODEC_IDX_AUDIO);
 410     ci.codec_get_buffer    = codec_get_buffer_callback;
 411     ci.pcmbuf_insert       = codec_pcmbuf_insert_callback;
 412     ci.set_elapsed         = audio_codec_update_elapsed;
 413     ci.read_filebuf        = codec_filebuf_callback;
 414     ci.request_buffer      = codec_request_buffer_callback;
 415     ci.advance_buffer      = codec_advance_buffer_callback;
 416     ci.seek_buffer         = codec_seek_buffer_callback;
 417     ci.seek_complete       = codec_seek_complete_callback;
 418     ci.set_offset          = audio_codec_update_offset;
 419     ci.configure           = codec_configure_callback;
 420     ci.get_command         = codec_get_command_callback;
 421 }
 422
 423
 424 /** --- CODEC THREAD --- **/
 425
 426 /* Handle Q_CODEC_LOAD */
 427 static void load_codec(const struct codec_load_info *ev_data)
 428 {
 429     int status = CODEC_ERROR;
 430     /* Save a local copy so we can let the audio thread go ASAP */
 431     struct codec_load_info data = *ev_data;
 432     bool const encoder = type_is_encoder(data.afmt);
 433
 434     if (codec_type != AFMT_UNKNOWN)
 435     {
 436         /* Must have unloaded it first */
 437         logf("a codec is already loaded");
 438         if (data.hid >= 0)
 439             bufclose(data.hid);
 440         return;
 441     }
 442
 443     trigger_cpu_boost();
 444
 445     if (!encoder)
 446     {
 447         /* Do this now because codec may set some things up at load time */
 448         dsp_configure(ci.dsp, DSP_RESET, 0);
 449     }
 450
 451     if (data.hid >= 0)
 452     {
 453         /* First try buffer load */
 454         status = codec_load_buf(data.hid, &ci);
 455         bufclose(data.hid);
 456     }
 457
 458     if (status < 0)
 459     {
 460         /* Either not a valid handle or the buffer method failed */
 461         const char *codec_fn = get_codec_filename(data.afmt);
 462         if (codec_fn)
 463         {
 464 #ifdef HAVE_IO_PRIORITY
 465             buf_back_off_storage(true);
 466 #endif
 467             status = codec_load_file(codec_fn, &ci);
 468 #ifdef HAVE_IO_PRIORITY
 469             buf_back_off_storage(false);
 470 #endif
 471         }
 472     }
 473
 474     if (status >= 0)
 475     {
 476         codec_type = data.afmt;
 477         codec_queue_ack(Q_CODEC_LOAD);
 478         return;
 479     }
 480
 481     /* Failed - get rid of it */
 482     unload_codec();
 483 }
 484
 485 /* Handle Q_CODEC_RUN */
 486 static void run_codec(void)
 487 {
 488     bool const encoder = type_is_encoder(codec_type);
 489     int status;
 490
 491     if (codec_type == AFMT_UNKNOWN)
 492     {
 493         logf("no codec to run");
 494         return;
 495     }
 496
 497     codec_queue_ack(Q_CODEC_RUN);
 498
 499     trigger_cpu_boost();
 500
 501     if (!encoder)
 502     {
 503         /* This will be either the initial buffered offset or where it left off
 504            if it remained buffered and we're skipping back to it and it is best
 505            to have ci.curpos in sync with the handle's read position - it's the
 506            codec's responsibility to ensure it has the correct positions -
 507            playback is sorta dumb and only has a vague idea about what to
 508            buffer based upon what metadata has to say */
 509         ci.curpos = bufftell(ci.audio_hid);
 510
 511         /* Pin the codec's audio data in place */
 512         buf_pin_handle(ci.audio_hid, true);
 513     }
 514
 515     status = codec_run_proc();
 516
 517     if (!encoder)
 518     {
 519         /* Codec is done with it - let it move */
 520         buf_pin_handle(ci.audio_hid, false);
 521
 522         /* Notify audio that we're done for better or worse - advise of the
 523            status */
 524         LOGFQUEUE("codec > audio Q_AUDIO_CODEC_COMPLETE: %d", status);
 525         audio_queue_post(Q_AUDIO_CODEC_COMPLETE, status);
 526     }
 527 }
 528
 529 /* Handle Q_CODEC_SEEK */
 530 static void seek_codec(unsigned long time)
 531 {
 532     if (codec_type == AFMT_UNKNOWN)
 533     {
 534         logf("no codec to seek");
 535         codec_queue_ack(Q_CODEC_SEEK);
 536         codec_seek_complete_callback();
 537         return;
 538     }
 539
 540     /* Post it up one level */
 541     queue_post(&codec_queue, Q_CODEC_SEEK, time);
 542     codec_queue_ack(Q_CODEC_SEEK);
 543
 544     /* Have to run it again */
 545     run_codec();
 546 }
 547
 548 /* Handle Q_CODEC_UNLOAD */
 549 static void unload_codec(void)
 550 {
 551     /* Tell codec to clean up */
 552     codec_type = AFMT_UNKNOWN;
 553     codec_close();
 554 }
 555
 556 /* Handle Q_CODEC_DO_CALLBACK */
 557 static void do_callback(void (* callback)(void))
 558 {
 559     codec_queue_ack(Q_CODEC_DO_CALLBACK);
 560
 561     if (callback)
 562     {
 563         cpucache_commit_discard();
 564         callback();
 565         cpucache_commit();
 566     }
 567 }
 568
 569 /* Codec thread function */
 570 static void NORETURN_ATTR codec_thread(void)
 571 {
 572     struct queue_event ev;
 573
 574     while (1)
 575     {
 576         cancel_cpu_boost();
 577
 578         queue_wait(&codec_queue, &ev);
 579
 580         switch (ev.id)
 581         {
 582         case Q_CODEC_LOAD:
 583             LOGFQUEUE("codec < Q_CODEC_LOAD");
 584             load_codec((const struct codec_load_info *)ev.data);
 585             break;
 586
 587         case Q_CODEC_RUN:
 588             LOGFQUEUE("codec < Q_CODEC_RUN");
 589             run_codec();
 590             break;
 591
 592         case Q_CODEC_PAUSE:
 593             LOGFQUEUE("codec < Q_CODEC_PAUSE");
 594             break;
 595
 596         case Q_CODEC_SEEK:
 597             LOGFQUEUE("codec < Q_CODEC_SEEK: %lu", (unsigned long)ev.data);
 598             seek_codec(ev.data);
 599             break;
 600
 601         case Q_CODEC_UNLOAD:
 602             LOGFQUEUE("codec < Q_CODEC_UNLOAD");
 603             unload_codec();
 604             break;
 605
 606         case Q_CODEC_DO_CALLBACK:
 607             LOGFQUEUE("codec < Q_CODEC_DO_CALLBACK");
 608             do_callback((void (*)(void))ev.data);
 609             break;
 610
 611         default:
 612             LOGFQUEUE("codec < default : %ld", ev.id);
 613         }
 614     }
 615 }
 616
 617
 618 /** --- Miscellaneous external interfaces -- **/
 619
 620 /* Create the codec thread and init kernel objects */
 621 void make_codec_thread(void)
 622 {
 623     queue_init(&codec_queue, false);
 624     codec_thread_id = create_thread(
 625             codec_thread, codec_stack, sizeof(codec_stack),
 626             CREATE_THREAD_FROZEN,
 627             codec_thread_name IF_PRIO(, PRIORITY_PLAYBACK)
 628             IF_COP(, CPU));
 629     queue_enable_queue_send(&codec_queue, &codec_queue_sender_list,
 630                             codec_thread_id);
 631 }
 632
 633 /* Unfreeze the codec thread */
 634 void codec_thread_resume(void)
 635 {
 636     thread_thaw(codec_thread_id);
 637 }
 638
 639 /* Is the current thread the codec thread? */
 640 bool is_codec_thread(void)
 641 {
 642     return thread_self() == codec_thread_id;
 643 }
 644
 645 #ifdef HAVE_PRIORITY_SCHEDULING
 646 /* Obtain codec thread's current priority */
 647 int codec_thread_get_priority(void)
 648 {
 649     return thread_get_priority(codec_thread_id);
 650 }
 651
 652 /* Set the codec thread's priority and return the old value */
 653 int codec_thread_set_priority(int priority)
 654 {
 655     return thread_set_priority(codec_thread_id, priority);
 656 }
 657 #endif /* HAVE_PRIORITY_SCHEDULING */
 658
 659
 660 /** --- Functions for audio thread use --- **/
 661
 662 /* Load a decoder or encoder and set the format type */
 663 bool codec_load(int hid, int cod_spec)
 664 {
 665     struct codec_load_info parm = { hid, cod_spec };
 666
 667     LOGFQUEUE("audio >| codec Q_CODEC_LOAD: %d, %d", hid, cod_spec);
 668     return codec_queue_send(Q_CODEC_LOAD, (intptr_t)&parm) != 0;
 669 }
 670
 671 /* Begin decoding the current file */
 672 void codec_go(void)
 673 {
 674     LOGFQUEUE("audio >| codec Q_CODEC_RUN");
 675     codec_queue_send(Q_CODEC_RUN, 0);
 676 }
 677
 678 /* Instruct the codec to seek to the specified time (should be properly
 679    paused or stopped first to avoid possible buffering deadlock) */
 680 void codec_seek(long time)
 681 {
 682     LOGFQUEUE("audio > codec Q_CODEC_SEEK: %ld", time);
 683     codec_queue_send(Q_CODEC_SEEK, time);
 684 }
 685
 686 /* Pause the codec and make it wait for further instructions inside the
 687    command callback */
 688 bool codec_pause(void)
 689 {
 690     LOGFQUEUE("audio >| codec Q_CODEC_PAUSE");
 691     return codec_queue_send(Q_CODEC_PAUSE, 0) != Q_NULL;
 692 }
 693
 694 /* Stop codec if running - codec stays resident if loaded */
 695 void codec_stop(void)
 696 {
 697     /* Wait until it's in the main loop */
 698     LOGFQUEUE("audio >| codec Q_CODEC_STOP");
 699     while (codec_queue_send(Q_CODEC_STOP, 0) != Q_NULL);
 700 }
 701
 702 /* Call the codec's exit routine and close all references */
 703 void codec_unload(void)
 704 {
 705     codec_stop();
 706     LOGFQUEUE("audio >| codec Q_CODEC_UNLOAD");
 707     codec_queue_send(Q_CODEC_UNLOAD, 0);
 708 }
 709
 710 /* Return the afmt type of the loaded codec - sticks until calling
 711    codec_unload unless initial load failed */
 712 int codec_loaded(void)
 713 {
 714     return codec_type;
 715 }