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