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     unsigned int last_seconds = 0;
 396 #if !defined(SIMULATOR)
 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 #endif /* SIMULATOR */
 551                 last_seconds = 0;
 552                 break;
 553 #endif /* #ifdef FM_RECORD */
 554
 555             case ACTION_FM_EXIT:
 556 #if CONFIG_CODEC != SWCODEC && !defined(SIMULATOR)
 557                 if(audio_status() == AUDIO_STATUS_RECORD)
 558                     audio_stop();
 559 #endif
 560                 keep_playing = true;
 561                 done = true;
 562                 if(presets_have_changed())
 563                 {
 564                     if(yesno_pop(ID2P(LANG_FM_SAVE_CHANGES)))
 565                     {
 566                         presets_save();
 567                     }
 568                 }
 569
 570                 break;
 571
 572             case ACTION_STD_PREV:
 573             case ACTION_STD_NEXT:
 574                 next_station(button == ACTION_STD_PREV ? -1 : 1);
 575                 end_search();
 576                 update_type = SKIN_REFRESH_ALL;
 577                 talk = true;
 578                 break;
 579
 580             case ACTION_STD_PREVREPEAT:
 581             case ACTION_STD_NEXTREPEAT:
 582             {
 583                 int dir = search_dir;
 584                 search_dir = button == ACTION_STD_PREVREPEAT ? -1 : 1;
 585                 if (radio_mode != RADIO_SCAN_MODE)
 586                 {
 587                     preset_next(search_dir);
 588                     end_search();
 589                     talk = true;
 590                 }
 591                 else if (dir == 0)
 592                 {
 593                     /* Starting auto scan */
 594                     tuner_set(RADIO_MUTE, 1);
 595                 }
 596                 update_type = SKIN_REFRESH_ALL;
 597                 break;
 598             }
 599
 600             case ACTION_SETTINGS_INC:
 601             case ACTION_SETTINGS_INCREPEAT:
 602                 global_settings.volume++;
 603                 setvol();
 604                 update_type = SKIN_REFRESH_NON_STATIC;
 605                 break;
 606
 607             case ACTION_SETTINGS_DEC:
 608             case ACTION_SETTINGS_DECREPEAT:
 609                 global_settings.volume--;
 610                 setvol();
 611                 update_type = SKIN_REFRESH_NON_STATIC;
 612                 break;
 613
 614             case ACTION_FM_PLAY:
 615                 if (radio_status == FMRADIO_PLAYING)
 616                     radio_pause();
 617                 else
 618                     radio_start();
 619
 620                 update_type = SKIN_REFRESH_NON_STATIC;
 621                 talk = false;
 622                 talk_shutup();
 623                 break;
 624
 625             case ACTION_FM_MENU:
 626                 fms_fix_displays(FMS_EXIT);
 627                 do_menu(&radio_settings_menu, NULL, NULL, false);
 628                 preset_set_current(preset_find(curr_freq));
 629                 fms_fix_displays(FMS_ENTER);
 630                 update_type = SKIN_REFRESH_ALL;
 631                 break;
 632
 633 #ifdef FM_PRESET
 634             case ACTION_FM_PRESET:
 635                 if(radio_preset_count() < 1)
 636                 {
 637                     splash(HZ, ID2P(LANG_FM_NO_PRESETS));
 638                     update_type = SKIN_REFRESH_ALL;
 639                     break;
 640                 }
 641                 fms_fix_displays(FMS_EXIT);
 642                 handle_radio_presets();
 643                 fms_fix_displays(FMS_ENTER);
 644                 update_type = SKIN_REFRESH_ALL;
 645                 break;
 646 #endif /* FM_PRESET */
 647
 648 #ifdef FM_FREEZE
 649             case ACTION_FM_FREEZE:
 650                 if(!screen_freeze)
 651                 {
 652                     splash(HZ, str(LANG_FM_FREEZE));
 653                     screen_freeze = true;
 654                 }
 655                 else
 656                 {
 657                     update_type = SKIN_REFRESH_ALL;
 658                     screen_freeze = false;
 659                 }
 660                 break;
 661 #endif /* FM_FREEZE */
 662
 663             case SYS_USB_CONNECTED:
 664 #if CONFIG_CODEC != SWCODEC
 665                 /* Only accept USB connection when not recording */
 666                 if(audio_status() != AUDIO_STATUS_RECORD)
 667 #endif
 668                 {
 669                     default_event_handler(SYS_USB_CONNECTED);
 670                     screen_freeze = true; /* Cosmetic: makes sure the
 671                                              radio screen doesn't redraw */
 672                     done = true;
 673                 }
 674                 break;
 675
 676 #ifdef FM_MODE
 677            case ACTION_FM_MODE:
 678                 if(radio_mode == RADIO_SCAN_MODE)
 679                 {
 680                     /* Force scan mode if there are no presets. */
 681                     if(radio_preset_count() > 0)
 682                         radio_mode = RADIO_PRESET_MODE;
 683                 }
 684                 else
 685                     radio_mode = RADIO_SCAN_MODE;
 686                 update_type = SKIN_REFRESH_ALL;
 687                 cond_talk_ids_fq(radio_mode ?
 688                                  LANG_PRESET : LANG_RADIO_SCAN_MODE);
 689                 talk = true;
 690                 break;
 691 #endif /* FM_MODE */
 692
 693 #ifdef FM_NEXT_PRESET
 694             case ACTION_FM_NEXT_PRESET:
 695                 preset_next(1);
 696                 end_search();
 697                 update_type = SKIN_REFRESH_ALL;
 698                 talk = true;
 699                 break;
 700 #endif
 701
 702 #ifdef FM_PREV_PRESET
 703             case ACTION_FM_PREV_PRESET:
 704                 preset_next(-1);
 705                 end_search();
 706                 update_type = SKIN_REFRESH_ALL;
 707                 talk = true;
 708                 break;
 709 #endif
 710             case ACTION_NONE:
 711                 update_type = SKIN_REFRESH_NON_STATIC;
 712                 break;
 713
 714             default:
 715                 default_event_handler(button);
 716 #ifdef HAVE_RDS_CAP
 717                 if (tuner_get(RADIO_EVENT))
 718                     update_type = SKIN_REFRESH_ALL;
 719 #endif
 720                 if (!tuner_get(RADIO_PRESENT))
 721                 {
 722 #if CONFIG_CODEC != SWCODEC && !defined(SIMULATOR)
 723                     if(audio_status() == AUDIO_STATUS_RECORD)
 724                         audio_stop();
 725 #endif
 726                     keep_playing = false;
 727                     done = true;
 728                     if(presets_have_changed())
 729                     {
 730                         if(yesno_pop(ID2P(LANG_FM_SAVE_CHANGES)))
 731                         {
 732                             radio_save_presets();
 733                         }
 734                     }
 735
 736                     /* Clear the preset list on exit. */
 737                     preset_list_clear();
 738                 }
 739                 break;
 740         } /*switch(button)*/
 741
 742 #ifdef FM_RECORD_DBLPRE
 743         if (button != ACTION_NONE)
 744             lastbutton = button;
 745 #endif
 746
 747 #if CONFIG_CODEC != SWCODEC
 748         peak_meter_peek();
 749 #endif
 750
 751         if(!screen_freeze)
 752         {
 753             /* Only display the peak meter when not recording */
 754 #if CONFIG_CODEC != SWCODEC
 755             if(TIME_AFTER(current_tick, timeout))
 756             {
 757                 timeout = current_tick + HZ;
 758 #else  /* SWCODEC */
 759             {
 760 #endif /* CONFIG_CODEC == SWCODEC */
 761
 762                 /* keep "mono" from always being displayed when paused */
 763                 if (radio_status != FMRADIO_PAUSED)
 764                 {
 765                     stereo = tuner_get(RADIO_STEREO) &&
 766                         !global_settings.fm_force_mono;
 767
 768                     if(stereo != last_stereo)
 769                     {
 770                         update_type = SKIN_REFRESH_ALL;
 771                         last_stereo = stereo;
 772                     }
 773                 }
 774             }
 775
 776 #if CONFIG_CODEC != SWCODEC && !defined(SIMULATOR)
 777             seconds = audio_recorded_time() / HZ;
 778             if (update_type || seconds > last_seconds)
 779             {
 780                 last_seconds = seconds;
 781 #else
 782             if (update_type)
 783             {
 784 #endif
 785                 FOR_NB_SCREENS(i)
 786                     skin_update(FM_SCREEN, i, update_type);
 787             }
 788         }
 789         update_type = 0;
 790
 791         if (global_settings.talk_file && talk
 792             && radio_status == FMRADIO_PAUSED)
 793         {
 794             talk = false;
 795             bool enqueue = false;
 796             if (radio_mode == RADIO_SCAN_MODE)
 797             {
 798                 talk_freq(curr_freq, enqueue);
 799                 enqueue = true;
 800             }
 801             if (radio_current_preset() >= 0)
 802                 preset_talk(radio_current_preset(), radio_mode == RADIO_PRESET_MODE,
 803                             enqueue);
 804         }
 805
 806 #if CONFIG_CODEC != SWCODEC
 807         if(audio_status() & AUDIO_STATUS_ERROR)
 808         {
 809             done = true;
 810         }
 811 #endif
 812
 813 #ifndef HAVE_NOISY_IDLE_MODE
 814         if (TIME_AFTER(current_tick, button_timeout))
 815         {
 816             cpu_idle_mode(true);
 817         }
 818 #endif
 819     } /*while(!done)*/
 820
 821 #ifndef SIMULATOR
 822 #if CONFIG_CODEC != SWCODEC
 823     if(audio_status() & AUDIO_STATUS_ERROR)
 824     {
 825         splash(0, str(LANG_DISK_FULL));
 826         audio_error_clear();
 827
 828         while(1)
 829         {
 830             button = get_action(CONTEXT_FM, TIMEOUT_BLOCK);
 831             if(button == ACTION_FM_STOP)
 832                 break;
 833         }
 834     }
 835
 836     audio_init_playback();
 837 #endif /* CONFIG_CODEC != SWCODEC */
 838
 839     sound_settings_apply();
 840 #endif /* SIMULATOR */
 841
 842     if(keep_playing)
 843     {
 844 /* Catch FMRADIO_PLAYING status for the sim. */
 845 #ifndef SIMULATOR
 846 #if CONFIG_CODEC != SWCODEC
 847         /* Enable the Left and right A/D Converter */
 848         audio_set_recording_gain(sound_default(SOUND_LEFT_GAIN),
 849                                  sound_default(SOUND_RIGHT_GAIN),
 850                                  AUDIO_GAIN_LINEIN);
 851         mas_codec_writereg(6, 0x4000);
 852 #endif
 853         end_search();
 854 #endif /* SIMULATOR */
 855     }
 856     else
 857     {
 858 #if CONFIG_CODEC == SWCODEC
 859         audio_set_input_source(AUDIO_SRC_PLAYBACK, SRCF_PLAYBACK);
 860 #else
 861         radio_stop();
 862 #endif
 863     }
 864
 865 #ifndef HAVE_NOISY_IDLE_MODE
 866     cpu_idle_mode(false);
 867 #endif
 868     fms_fix_displays(FMS_EXIT);
 869     in_screen = false;
 870 } /* radio_screen */
 871
 872 void toggle_mono_mode(bool mono)
 873 {
 874     tuner_set(RADIO_FORCE_MONO, mono);
 875 }
 876
 877 void set_radio_region(int region)
 878 {
 879 #ifdef HAVE_RADIO_REGION
 880     tuner_set(RADIO_REGION, region);
 881 #endif
 882     next_station(0);
 883     remember_frequency();
 884     (void)region;
 885 }
 886
 887 #endif