apps/radio/radio.c

   1 /***************************************************************************
   2  *             __________               __   ___.
   3  *   Open      \______   \ ____   ____ |  | _\_ |__   _______  ___
   4  *   Source     |       _//  _ \_/ ___\|  |/ /| __ \ /  _ \  \/  /
   5  *   Jukebox    |    |   (  <_> )  \___|    < | \_\ (  <_> > <  <
   6  *   Firmware   |____|_  /\____/ \___  >__|_ \|___  /\____/__/\_ \
   7  *                     \/            \/     \/    \/            \/
   8  * $Id$
   9  *
  10  * Copyright (C) 2003 Linus Nielsen Feltzing
  11  *
  12  * This program is free software; you can redistribute it and/or
  13  * modify it under the terms of the GNU General Public License
  14  * as published by the Free Software Foundation; either version 2
  15  * of the License, or (at your option) any later version.
  16  *
  17  * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY
  18  * KIND, either express or implied.
  19  *
  20  ****************************************************************************/
  21
  22 #include <stdio.h>
  23 #include <stdbool.h>
  24 #include <stdlib.h>
  25 #include "config.h"
  26 #include "system.h"
  27 #include "settings.h"
  28 #include "status.h"
  29 #include "audio.h"
  30 #include "general.h"
  31 #include "radio.h"
  32 #include "menu.h"
  33 #include "menus/exported_menus.h"
  34 #include "misc.h"
  35 #include "screens.h"
  36 #include "peakmeter.h"
  37 #include "lang.h"
  38 #ifdef HAVE_RECORDING
  39 #include "recording.h"
  40 #endif
  41 #ifdef IPOD_ACCESSORY_PROTOCOL
  42 #include "iap.h"
  43 #endif
  44 #include "talk.h"
  45 #include "tuner.h"
  46 #include "power.h"
  47 #include "sound.h"
  48 #include "screen_access.h"
  49 #include "splash.h"
  50 #include "yesno.h"
  51 #include "tree.h"
  52 #include "dir.h"
  53 #include "action.h"
  54 #include "viewport.h"
  55 #include "skin_engine/skin_engine.h"
  56 #include "statusbar-skinned.h"
  57 #if CONFIG_CODEC == SWCODEC
  58 #include "playback.h"
  59 #endif
  60 #include "presets.h"
  61
  62 #if CONFIG_TUNER
  63
  64 #if CONFIG_KEYPAD == RECORDER_PAD
  65 #define FM_RECORD
  66 #define FM_PRESET_ADD
  67 #define FM_PRESET_ACTION
  68 #define FM_PRESET
  69 #define FM_MODE
  70
  71 #elif (CONFIG_KEYPAD == IRIVER_H100_PAD) || (CONFIG_KEYPAD == IRIVER_H300_PAD)
  72 #define FM_PRESET
  73 #define FM_MODE
  74 #define FM_NEXT_PRESET
  75 #define FM_PREV_PRESET
  76
  77 #elif CONFIG_KEYPAD == IRIVER_H10_PAD
  78 #define FM_PRESET
  79 #define FM_MODE
  80
  81 #elif (CONFIG_KEYPAD == IAUDIO_X5M5_PAD)
  82 #define FM_PRESET
  83 #define FM_MODE
  84 /* This should be removeable if the whole tuning thing is sorted out since
  85    proper tuning quiets the screen almost entirely in that extreme measures
  86    have to be taken to hear any interference. */
  87 #define HAVE_NOISY_IDLE_MODE
  88
  89 #elif CONFIG_KEYPAD == ONDIO_PAD
  90 #define FM_RECORD_DBLPRE
  91 #define FM_RECORD
  92
  93 #elif (CONFIG_KEYPAD == SANSA_E200_PAD) || (CONFIG_KEYPAD == SANSA_C200_PAD) ||\
  94       (CONFIG_KEYPAD == SANSA_FUZE_PAD) || (CONFIG_KEYPAD == SANSA_CLIP_PAD)
  95 #define FM_MENU
  96 #define FM_PRESET
  97 #define FM_STOP
  98 #define FM_MODE
  99 #define FM_EXIT
 100 #define FM_PLAY
 101
 102 #elif (CONFIG_KEYPAD == GIGABEAT_S_PAD)
 103 #define FM_PRESET
 104 #define FM_MODE
 105
 106 #elif (CONFIG_KEYPAD == COWON_D2_PAD)
 107 #define FM_MENU
 108 #define FM_PRESET
 109 #define FM_STOP
 110 #define FM_MODE
 111 #define FM_EXIT
 112 #define FM_PLAY
 113
 114 #elif (CONFIG_KEYPAD == IPOD_4G_PAD) || (CONFIG_KEYPAD == IPOD_3G_PAD) || \
 115     (CONFIG_KEYPAD == IPOD_1G2G_PAD)
 116 #define FM_MENU
 117 #define FM_STOP
 118 #define FM_EXIT
 119 #define FM_PLAY
 120 #define FM_MODE
 121
 122 #elif (CONFIG_KEYPAD == MPIO_HD200_PAD)
 123 #define FM_MENU
 124 #define FM_STOP
 125 #define FM_EXIT
 126 #define FM_PLAY
 127 #define FM_MODE
 128 #define FM_STOP
 129
 130 #endif
 131
 132 /* presets.c needs these so keep unstatic or redo the whole thing! */
 133 int curr_freq; /* current frequency in Hz */
 134 int radio_mode = RADIO_SCAN_MODE;
 135
 136 static int search_dir = 0;
 137 static int radio_status = FMRADIO_OFF;
 138 static bool in_screen = false;
 139
 140
 141 static void radio_off(void);
 142
 143 bool radio_scan_mode(void)
 144 {
 145     return radio_mode == RADIO_SCAN_MODE;
 146 }
 147
 148 bool radio_is_stereo(void)
 149 {
 150     return tuner_get(RADIO_STEREO) && !global_settings.fm_force_mono;
 151 }
 152 int radio_current_frequency(void)
 153 {
 154     return curr_freq;
 155 }
 156
 157 /* Function to manipulate all yesno dialogues.
 158    This function needs the output text as an argument. */
 159 bool yesno_pop(const char* text)
 160 {
 161     int i;
 162     const char *lines[]={text};
 163     const struct text_message message={lines, 1};
 164     bool ret = (gui_syncyesno_run(&message,NULL,NULL)== YESNO_YES);
 165     FOR_NB_SCREENS(i)
 166         screens[i].clear_viewport();
 167     return ret;
 168 }
 169
 170 void radio_init(void)
 171 {
 172     tuner_init();
 173     radio_off();
 174 #ifdef HAVE_ALBUMART
 175     radioart_init(false);
 176 #endif
 177 }
 178
 179 int get_radio_status(void)
 180 {
 181     return radio_status;
 182 }
 183
 184 bool in_radio_screen(void)
 185 {
 186     return in_screen;
 187 }
 188
 189 /* TODO: Move some more of the control functionality to firmware
 190          and clean up the mess */
 191
 192 /* secret flag for starting paused - prevents unmute */
 193 #define FMRADIO_START_PAUSED 0x8000
 194 void radio_start(void)
 195 {
 196     const struct fm_region_data *fmr;
 197     bool start_paused;
 198
 199     if(radio_status == FMRADIO_PLAYING)
 200         return;
 201
 202     fmr = &fm_region_data[global_settings.fm_region];
 203
 204     start_paused = radio_status & FMRADIO_START_PAUSED;
 205     /* clear flag before any yielding */
 206     radio_status &= ~FMRADIO_START_PAUSED;
 207
 208     if(radio_status == FMRADIO_OFF)
 209         tuner_power(true);
 210
 211     curr_freq = global_status.last_frequency * fmr->freq_step + fmr->freq_min;
 212
 213     tuner_set(RADIO_SLEEP, 0); /* wake up the tuner */
 214
 215     if(radio_status == FMRADIO_OFF)
 216     {
 217 #ifdef HAVE_RADIO_REGION
 218         tuner_set(RADIO_REGION, global_settings.fm_region);
 219 #endif
 220         tuner_set(RADIO_FORCE_MONO, global_settings.fm_force_mono);
 221     }
 222
 223     tuner_set(RADIO_FREQUENCY, curr_freq);
 224
 225 #ifdef HAVE_RADIO_MUTE_TIMEOUT
 226     {
 227         unsigned long mute_timeout = current_tick + HZ;
 228         if (radio_status != FMRADIO_OFF)
 229         {
 230             /* paused */
 231             mute_timeout += HZ;
 232         }
 233
 234         while(!tuner_get(RADIO_STEREO) && !tuner_get(RADIO_TUNED))
 235         {
 236             if(TIME_AFTER(current_tick, mute_timeout))
 237                  break;
 238             yield();
 239         }
 240     }
 241 #endif
 242
 243     /* keep radio from sounding initially */
 244     if(!start_paused)
 245         tuner_set(RADIO_MUTE, 0);
 246
 247     radio_status = FMRADIO_PLAYING;
 248 } /* radio_start */
 249
 250 void radio_pause(void)
 251 {
 252     if(radio_status == FMRADIO_PAUSED)
 253         return;
 254
 255     if(radio_status == FMRADIO_OFF)
 256     {
 257         radio_status |= FMRADIO_START_PAUSED;
 258         radio_start();
 259     }
 260
 261     tuner_set(RADIO_MUTE, 1);
 262     /* For si4700: 2==this is really 'pause'. other tuners treat it
 263      * like 'bool'. */
 264     tuner_set(RADIO_SLEEP, 2);
 265
 266     radio_status = FMRADIO_PAUSED;
 267 } /* radio_pause */
 268
 269 static void radio_off(void)
 270 {
 271     tuner_set(RADIO_MUTE, 1);
 272     tuner_set(RADIO_SLEEP, 1); /* low power mode, if available */
 273     radio_status = FMRADIO_OFF;
 274     tuner_power(false); /* status update, power off if avail. */
 275 }
 276
 277 void radio_stop(void)
 278 {
 279     if(radio_status == FMRADIO_OFF)
 280         return;
 281
 282     radio_off();
 283 } /* radio_stop */
 284
 285 bool radio_hardware_present(void)
 286 {
 287     return tuner_get(RADIO_PRESENT);
 288 }
 289
 290 /* Keep freq on the grid for the current region */
 291 int snap_freq_to_grid(int freq)
 292 {
 293     const struct fm_region_data * const fmr =
 294         &fm_region_data[global_settings.fm_region];
 295
 296     /* Range clamp if out of range or just round to nearest */
 297     if (freq < fmr->freq_min)
 298         freq = fmr->freq_min;
 299     else if (freq > fmr->freq_max)
 300         freq = fmr->freq_max;
 301     else
 302         freq = (freq - fmr->freq_min + fmr->freq_step/2) /
 303                 fmr->freq_step * fmr->freq_step + fmr->freq_min;
 304
 305     return freq;
 306 }
 307
 308 void remember_frequency(void)
 309 {
 310     const struct fm_region_data * const fmr =
 311         &fm_region_data[global_settings.fm_region];
 312     global_status.last_frequency = (curr_freq - fmr->freq_min)
 313                                    / fmr->freq_step;
 314     status_save();
 315 }
 316
 317 /* Step to the next or previous frequency */
 318 static int step_freq(int freq, int direction)
 319 {
 320     const struct fm_region_data * const fmr =
 321         &fm_region_data[global_settings.fm_region];
 322
 323     freq += direction*fmr->freq_step;
 324
 325     /* Wrap first or snapping to grid will not let us on the band extremes */
 326     if (freq > fmr->freq_max)
 327         freq = direction > 0 ? fmr->freq_min : fmr->freq_max;
 328     else if (freq < fmr->freq_min)
 329         freq = direction < 0 ? fmr->freq_max : fmr->freq_min;
 330     else
 331         freq = snap_freq_to_grid(freq);
 332
 333     return freq;
 334 }
 335
 336 /* Step to the next or previous station */
 337 void next_station(int direction)
 338 {
 339     if (direction != 0 && radio_mode != RADIO_SCAN_MODE)
 340     {
 341         preset_next(direction);
 342         return;
 343     }
 344
 345     curr_freq = step_freq(curr_freq, direction);
 346
 347     if (radio_status == FMRADIO_PLAYING)
 348         tuner_set(RADIO_MUTE, 1);
 349
 350     tuner_set(RADIO_FREQUENCY, curr_freq);
 351
 352     if (radio_status == FMRADIO_PLAYING)
 353         tuner_set(RADIO_MUTE, 0);
 354
 355     preset_set_current(preset_find(curr_freq));
 356     remember_frequency();
 357 }
 358
 359 /* Ends an in-progress search */
 360 static void end_search(void)
 361 {
 362     if (search_dir != 0 && radio_status == FMRADIO_PLAYING)
 363         tuner_set(RADIO_MUTE, 0);
 364     search_dir = 0;
 365 }
 366
 367 /* Speak a frequency. */
 368 void talk_freq(int freq, bool enqueue)
 369 {
 370     freq /= 10000;
 371     talk_number(freq / 100, enqueue);
 372     talk_id(LANG_POINT, true);
 373     talk_number(freq % 100 / 10, true);
 374     if (freq % 10)
 375         talk_number(freq % 10, true);
 376 }
 377
 378
 379 void radio_screen(void)
 380 {
 381     bool done = false;
 382     int button;
 383     int i;
 384     bool stereo = false, last_stereo = false;
 385     int update_type = 0;
 386     bool screen_freeze = false;
 387     bool keep_playing = false;
 388     bool talk = false;
 389 #ifdef FM_RECORD_DBLPRE
 390     int lastbutton = BUTTON_NONE;
 391     unsigned long rec_lastclick = 0;
 392 #endif
 393 #if CONFIG_CODEC != SWCODEC
 394     int timeout = current_tick + HZ/10;
 395 #if !defined(SIMULATOR)
 396     unsigned int last_seconds = 0;
 397     unsigned int seconds = 0;
 398     struct audio_recording_options rec_options;
 399 #endif /* SIMULATOR */
 400 #endif /* CONFIG_CODEC != SWCODEC */
 401 #ifndef HAVE_NOISY_IDLE_MODE
 402     int button_timeout = current_tick + (2*HZ);
 403 #endif
 404
 405     /* change status to "in screen" */
 406     in_screen = true;
 407
 408     if(radio_preset_count() <= 0)
 409     {
 410         radio_load_presets(global_settings.fmr_file);
 411     }
 412     skin_get_global_state()->id3 = NULL;
 413 #ifdef HAVE_ALBUMART
 414     radioart_init(true);
 415 #endif
 416
 417     if(radio_status == FMRADIO_OFF)
 418         audio_stop();
 419
 420 #ifndef SIMULATOR
 421
 422 #if CONFIG_CODEC != SWCODEC
 423     rec_create_directory();
 424     audio_init_recording(talk_get_bufsize());
 425
 426     sound_settings_apply();
 427     /* Yes, we use the D/A for monitoring */
 428     peak_meter_playback(true);
 429
 430     peak_meter_enable(true);
 431
 432     rec_init_recording_options(&rec_options);
 433     rec_options.rec_source = AUDIO_SRC_LINEIN;
 434     rec_set_recording_options(&rec_options);
 435
 436     audio_set_recording_gain(sound_default(SOUND_LEFT_GAIN),
 437             sound_default(SOUND_RIGHT_GAIN), AUDIO_GAIN_LINEIN);
 438
 439 #endif /* CONFIG_CODEC != SWCODEC */
 440 #endif /* ndef SIMULATOR */
 441
 442     /* turn on radio */
 443 #if CONFIG_CODEC == SWCODEC
 444     /* This should be done before touching audio settings */
 445     while (!audio_is_thread_ready())
 446        sleep(0);
 447
 448     audio_set_input_source(AUDIO_SRC_FMRADIO,
 449                            (radio_status == FMRADIO_PAUSED) ?
 450                                SRCF_FMRADIO_PAUSED : SRCF_FMRADIO_PLAYING);
 451 #else
 452     if (radio_status == FMRADIO_OFF)
 453         radio_start();
 454 #endif
 455
 456     if(radio_preset_count() < 1 && yesno_pop(ID2P(LANG_FM_FIRST_AUTOSCAN)))
 457         presets_scan(NULL);
 458
 459     fms_fix_displays(FMS_ENTER);
 460     FOR_NB_SCREENS(i)
 461         skin_update(FM_SCREEN, i, SKIN_REFRESH_ALL);
 462
 463     preset_set_current(preset_find(curr_freq));
 464     if(radio_current_preset() != -1)
 465          radio_mode = RADIO_PRESET_MODE;
 466
 467 #ifndef HAVE_NOISY_IDLE_MODE
 468     cpu_idle_mode(true);
 469 #endif
 470
 471     while(!done)
 472     {
 473         if(search_dir != 0)
 474         {
 475             curr_freq = step_freq(curr_freq, search_dir);
 476             update_type = SKIN_REFRESH_ALL;
 477
 478             if(tuner_set(RADIO_SCAN_FREQUENCY, curr_freq))
 479             {
 480                 preset_set_current(preset_find(curr_freq));
 481                 remember_frequency();
 482                 end_search();
 483                 talk = true;
 484             }
 485             trigger_cpu_boost();
 486         }
 487
 488         if (!update_type)
 489         {
 490             cancel_cpu_boost();
 491         }
 492
 493         button = fms_do_button_loop(update_type>0);
 494
 495 #ifndef HAVE_NOISY_IDLE_MODE
 496         if (button != ACTION_NONE)
 497         {
 498             cpu_idle_mode(false);
 499             button_timeout = current_tick + (2*HZ);
 500         }
 501 #endif
 502         switch(button)
 503         {
 504              case ACTION_FM_STOP:
 505 #if CONFIG_CODEC != SWCODEC && !defined(SIMULATOR)
 506                 if(audio_status() == AUDIO_STATUS_RECORD)
 507                 {
 508                     audio_stop();
 509                 }
 510                 else
 511 #endif
 512                 {
 513                     done = true;
 514                     if(presets_have_changed())
 515                     {
 516                         if(yesno_pop(ID2P(LANG_FM_SAVE_CHANGES)))
 517                         {
 518                             presets_save();
 519                         }
 520                     }
 521                 }
 522                 update_type = SKIN_REFRESH_NON_STATIC;
 523                 break;
 524
 525 #ifdef FM_RECORD
 526             case ACTION_FM_RECORD:
 527 #ifdef FM_RECORD_DBLPRE
 528                 if (lastbutton != ACTION_FM_RECORD_DBLPRE)
 529                 {
 530                     rec_lastclick = 0;
 531                     break;
 532                 }
 533                 if (current_tick - rec_lastclick > HZ/2)
 534                 {
 535                     rec_lastclick = current_tick;
 536                     break;
 537                 }
 538 #endif /* FM_RECORD_DBLPRE */
 539 #ifndef SIMULATOR
 540                 if(audio_status() == AUDIO_STATUS_RECORD)
 541                 {
 542                     rec_command(RECORDING_CMD_START_NEWFILE);
 543                     update_type = SKIN_REFRESH_ALL;
 544                 }
 545                 else
 546                 {
 547                     rec_command(RECORDING_CMD_START);
 548                     update_type = SKIN_REFRESH_ALL;
 549                 }
 550 #if CONFIG_CODEC != SWCODEC
 551                 last_seconds = 0;
 552 #endif
 553 #endif /* SIMULATOR */
 554                 break;
 555 #endif /* #ifdef FM_RECORD */
 556
 557             case ACTION_FM_EXIT:
 558 #if CONFIG_CODEC != SWCODEC && !defined(SIMULATOR)
 559                 if(audio_status() == AUDIO_STATUS_RECORD)
 560                     audio_stop();
 561 #endif
 562                 keep_playing = true;
 563                 done = true;
 564                 if(presets_have_changed())
 565                 {
 566                     if(yesno_pop(ID2P(LANG_FM_SAVE_CHANGES)))
 567                     {
 568                         presets_save();
 569                     }
 570                 }
 571
 572                 break;
 573
 574             case ACTION_STD_PREV:
 575             case ACTION_STD_NEXT:
 576                 next_station(button == ACTION_STD_PREV ? -1 : 1);
 577                 end_search();
 578                 update_type = SKIN_REFRESH_ALL;
 579                 talk = true;
 580                 break;
 581
 582             case ACTION_STD_PREVREPEAT:
 583             case ACTION_STD_NEXTREPEAT:
 584             {
 585                 int dir = search_dir;
 586                 search_dir = button == ACTION_STD_PREVREPEAT ? -1 : 1;
 587                 if (radio_mode != RADIO_SCAN_MODE)
 588                 {
 589                     preset_next(search_dir);
 590                     end_search();
 591                     talk = true;
 592                 }
 593                 else if (dir == 0)
 594                 {
 595                     /* Starting auto scan */
 596                     tuner_set(RADIO_MUTE, 1);
 597                 }
 598                 update_type = SKIN_REFRESH_ALL;
 599                 break;
 600             }
 601
 602             case ACTION_SETTINGS_INC:
 603             case ACTION_SETTINGS_INCREPEAT:
 604                 global_settings.volume++;
 605                 setvol();
 606                 update_type = SKIN_REFRESH_NON_STATIC;
 607                 break;
 608
 609             case ACTION_SETTINGS_DEC:
 610             case ACTION_SETTINGS_DECREPEAT:
 611                 global_settings.volume--;
 612                 setvol();
 613                 update_type = SKIN_REFRESH_NON_STATIC;
 614                 break;
 615
 616             case ACTION_FM_PLAY:
 617                 if (radio_status == FMRADIO_PLAYING)
 618                     radio_pause();
 619                 else
 620                     radio_start();
 621
 622                 update_type = SKIN_REFRESH_NON_STATIC;
 623                 talk = false;
 624                 talk_shutup();
 625                 break;
 626
 627             case ACTION_FM_MENU:
 628                 fms_fix_displays(FMS_EXIT);
 629                 do_menu(&radio_settings_menu, NULL, NULL, false);
 630                 preset_set_current(preset_find(curr_freq));
 631                 fms_fix_displays(FMS_ENTER);
 632                 update_type = SKIN_REFRESH_ALL;
 633                 break;
 634
 635 #ifdef FM_PRESET
 636             case ACTION_FM_PRESET:
 637                 if(radio_preset_count() < 1)
 638                 {
 639                     splash(HZ, ID2P(LANG_FM_NO_PRESETS));
 640                     update_type = SKIN_REFRESH_ALL;
 641                     break;
 642                 }
 643                 fms_fix_displays(FMS_EXIT);
 644                 handle_radio_presets();
 645                 fms_fix_displays(FMS_ENTER);
 646                 update_type = SKIN_REFRESH_ALL;
 647                 break;
 648 #endif /* FM_PRESET */
 649
 650 #ifdef FM_FREEZE
 651             case ACTION_FM_FREEZE:
 652                 if(!screen_freeze)
 653                 {
 654                     splash(HZ, str(LANG_FM_FREEZE));
 655                     screen_freeze = true;
 656                 }
 657                 else
 658                 {
 659                     update_type = SKIN_REFRESH_ALL;
 660                     screen_freeze = false;
 661                 }
 662                 break;
 663 #endif /* FM_FREEZE */
 664
 665             case SYS_USB_CONNECTED:
 666 #if CONFIG_CODEC != SWCODEC
 667                 /* Only accept USB connection when not recording */
 668                 if(audio_status() != AUDIO_STATUS_RECORD)
 669 #endif
 670                 {
 671                     default_event_handler(SYS_USB_CONNECTED);
 672                     screen_freeze = true; /* Cosmetic: makes sure the
 673                                              radio screen doesn't redraw */
 674                     done = true;
 675                 }
 676                 break;
 677
 678 #ifdef FM_MODE
 679            case ACTION_FM_MODE:
 680                 if(radio_mode == RADIO_SCAN_MODE)
 681                 {
 682                     /* Force scan mode if there are no presets. */
 683                     if(radio_preset_count() > 0)
 684                         radio_mode = RADIO_PRESET_MODE;
 685                 }
 686                 else
 687                     radio_mode = RADIO_SCAN_MODE;
 688                 update_type = SKIN_REFRESH_ALL;
 689                 cond_talk_ids_fq(radio_mode ?
 690                                  LANG_PRESET : LANG_RADIO_SCAN_MODE);
 691                 talk = true;
 692                 break;
 693 #endif /* FM_MODE */
 694
 695 #ifdef FM_NEXT_PRESET
 696             case ACTION_FM_NEXT_PRESET:
 697                 preset_next(1);
 698                 end_search();
 699                 update_type = SKIN_REFRESH_ALL;
 700                 talk = true;
 701                 break;
 702 #endif
 703
 704 #ifdef FM_PREV_PRESET
 705             case ACTION_FM_PREV_PRESET:
 706                 preset_next(-1);
 707                 end_search();
 708                 update_type = SKIN_REFRESH_ALL;
 709                 talk = true;
 710                 break;
 711 #endif
 712             case ACTION_NONE:
 713                 update_type = SKIN_REFRESH_NON_STATIC;
 714                 break;
 715
 716             default:
 717                 default_event_handler(button);
 718 #ifdef HAVE_RDS_CAP
 719                 if (tuner_get(RADIO_EVENT))
 720                     update_type = SKIN_REFRESH_ALL;
 721 #endif
 722                 if (!tuner_get(RADIO_PRESENT))
 723                 {
 724 #if CONFIG_CODEC != SWCODEC && !defined(SIMULATOR)
 725                     if(audio_status() == AUDIO_STATUS_RECORD)
 726                         audio_stop();
 727 #endif
 728                     keep_playing = false;
 729                     done = true;
 730                     if(presets_have_changed())
 731                     {
 732                         if(yesno_pop(ID2P(LANG_FM_SAVE_CHANGES)))
 733                         {
 734                             radio_save_presets();
 735                         }
 736                     }
 737
 738                     /* Clear the preset list on exit. */
 739                     preset_list_clear();
 740                 }
 741                 break;
 742         } /*switch(button)*/
 743
 744 #ifdef FM_RECORD_DBLPRE
 745         if (button != ACTION_NONE)
 746             lastbutton = button;
 747 #endif
 748
 749 #if CONFIG_CODEC != SWCODEC
 750         peak_meter_peek();
 751 #endif
 752
 753         if(!screen_freeze)
 754         {
 755             /* Only display the peak meter when not recording */
 756 #if CONFIG_CODEC != SWCODEC
 757             if(TIME_AFTER(current_tick, timeout))
 758             {
 759                 timeout = current_tick + HZ;
 760 #else  /* SWCODEC */
 761             {
 762 #endif /* CONFIG_CODEC == SWCODEC */
 763
 764                 /* keep "mono" from always being displayed when paused */
 765                 if (radio_status != FMRADIO_PAUSED)
 766                 {
 767                     stereo = tuner_get(RADIO_STEREO) &&
 768                         !global_settings.fm_force_mono;
 769
 770                     if(stereo != last_stereo)
 771                     {
 772                         update_type = SKIN_REFRESH_ALL;
 773                         last_stereo = stereo;
 774                     }
 775                 }
 776             }
 777
 778 #if CONFIG_CODEC != SWCODEC && !defined(SIMULATOR)
 779             seconds = audio_recorded_time() / HZ;
 780             if (update_type || seconds > last_seconds)
 781             {
 782                 last_seconds = seconds;
 783 #else
 784             if (update_type)
 785             {
 786 #endif
 787                 FOR_NB_SCREENS(i)
 788                     skin_update(FM_SCREEN, i, update_type);
 789             }
 790         }
 791         update_type = 0;
 792
 793         if (global_settings.talk_file && talk
 794             && radio_status == FMRADIO_PAUSED)
 795         {
 796             talk = false;
 797             bool enqueue = false;
 798             if (radio_mode == RADIO_SCAN_MODE)
 799             {
 800                 talk_freq(curr_freq, enqueue);
 801                 enqueue = true;
 802             }
 803             if (radio_current_preset() >= 0)
 804                 preset_talk(radio_current_preset(), radio_mode == RADIO_PRESET_MODE,
 805                             enqueue);
 806         }
 807
 808 #if CONFIG_CODEC != SWCODEC
 809         if(audio_status() & AUDIO_STATUS_ERROR)
 810         {
 811             done = true;
 812         }
 813 #endif
 814
 815 #ifndef HAVE_NOISY_IDLE_MODE
 816         if (TIME_AFTER(current_tick, button_timeout))
 817         {
 818             cpu_idle_mode(true);
 819         }
 820 #endif
 821     } /*while(!done)*/
 822
 823 #ifndef SIMULATOR
 824 #if CONFIG_CODEC != SWCODEC
 825     if(audio_status() & AUDIO_STATUS_ERROR)
 826     {
 827         splash(0, str(LANG_DISK_FULL));
 828         audio_error_clear();
 829
 830         while(1)
 831         {
 832             button = get_action(CONTEXT_FM, TIMEOUT_BLOCK);
 833             if(button == ACTION_FM_STOP)
 834                 break;
 835         }
 836     }
 837
 838     audio_init_playback();
 839 #endif /* CONFIG_CODEC != SWCODEC */
 840
 841     sound_settings_apply();
 842 #endif /* SIMULATOR */
 843
 844     if(keep_playing)
 845     {
 846 /* Catch FMRADIO_PLAYING status for the sim. */
 847 #ifndef SIMULATOR
 848 #if CONFIG_CODEC != SWCODEC
 849         /* Enable the Left and right A/D Converter */
 850         audio_set_recording_gain(sound_default(SOUND_LEFT_GAIN),
 851                                  sound_default(SOUND_RIGHT_GAIN),
 852                                  AUDIO_GAIN_LINEIN);
 853         mas_codec_writereg(6, 0x4000);
 854 #endif
 855         end_search();
 856 #endif /* SIMULATOR */
 857     }
 858     else
 859     {
 860 #if CONFIG_CODEC == SWCODEC
 861         audio_set_input_source(AUDIO_SRC_PLAYBACK, SRCF_PLAYBACK);
 862 #else
 863         radio_stop();
 864 #endif
 865     }
 866
 867 #ifndef HAVE_NOISY_IDLE_MODE
 868     cpu_idle_mode(false);
 869 #endif
 870     fms_fix_displays(FMS_EXIT);
 871     in_screen = false;
 872 } /* radio_screen */
 873
 874 void toggle_mono_mode(bool mono)
 875 {
 876     tuner_set(RADIO_FORCE_MONO, mono);
 877 }
 878
 879 void set_radio_region(int region)
 880 {
 881 #ifdef HAVE_RADIO_REGION
 882     tuner_set(RADIO_REGION, region);
 883 #endif
 884     next_station(0);
 885     remember_frequency();
 886     (void)region;
 887 }
 888
 889 #endif