apps/recorder/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 "sprintf.h"
  27 #include "mas.h"
  28 #include "settings.h"
  29 #include "button.h"
  30 #include "status.h"
  31 #include "thread.h"
  32 #include "audio.h"
  33 #include "mp3_playback.h"
  34 #include "ctype.h"
  35 #include "file.h"
  36 #include "general.h"
  37 #include "errno.h"
  38 #include "string.h"
  39 #include "system.h"
  40 #include "radio.h"
  41 #include "menu.h"
  42 #include "misc.h"
  43 #include "keyboard.h"
  44 #include "screens.h"
  45 #include "peakmeter.h"
  46 #include "lang.h"
  47 #include "font.h"
  48 #include "sound_menu.h"
  49 #ifdef HAVE_RECORDING
  50 #include "recording.h"
  51 #endif
  52 #ifdef IPOD_ACCESSORY_PROTOCOL
  53 #include "iap.h"
  54 #endif
  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 #ifdef HAVE_QUICKSCREEN
  71 #include "quickscreen.h"
  72 #endif
  73
  74 #if CONFIG_TUNER
  75
  76 #if CONFIG_KEYPAD == RECORDER_PAD
  77 #define FM_RECORD
  78 #define FM_PRESET_ADD
  79 #define FM_PRESET_ACTION
  80 #define FM_PRESET
  81 #define FM_MODE
  82
  83 #elif (CONFIG_KEYPAD == IRIVER_H100_PAD) || (CONFIG_KEYPAD == IRIVER_H300_PAD)
  84 #define FM_PRESET
  85 #define FM_MODE
  86 #define FM_NEXT_PRESET
  87 #define FM_PREV_PRESET
  88
  89 #elif CONFIG_KEYPAD == IRIVER_H10_PAD
  90 #define FM_PRESET
  91 #define FM_MODE
  92
  93 #elif (CONFIG_KEYPAD == IAUDIO_X5M5_PAD)
  94 #define FM_PRESET
  95 #define FM_MODE
  96 /* This should be removeable if the whole tuning thing is sorted out since
  97    proper tuning quiets the screen almost entirely in that extreme measures
  98    have to be taken to hear any interference. */
  99 #define HAVE_NOISY_IDLE_MODE
 100
 101 #elif CONFIG_KEYPAD == ONDIO_PAD
 102 #define FM_RECORD_DBLPRE
 103 #define FM_RECORD
 104 #elif (CONFIG_KEYPAD == SANSA_E200_PAD) || (CONFIG_KEYPAD == SANSA_C200_PAD) \
 105    || (CONFIG_KEYPAD == SANSA_FUZE_PAD)
 106 #define FM_PRESET
 107 #define FM_MODE
 108
 109 #elif (CONFIG_KEYPAD == GIGABEAT_S_PAD)
 110 #define FM_PRESET
 111 #define FM_MODE
 112
 113 #elif (CONFIG_KEYPAD == COWON_D2_PAD)
 114 #define FM_PRESET
 115
 116 #elif (CONFIG_KEYPAD == IPOD_4G_PAD) || (CONFIG_KEYPAD == IPOD_3G_PAD) || \
 117     (CONFIG_KEYPAD == IPOD_1G2G_PAD)
 118 #define FM_MODE
 119
 120 #endif
 121
 122 #define RADIO_SCAN_MODE 0
 123 #define RADIO_PRESET_MODE 1
 124
 125 static int curr_preset = -1;
 126 static int curr_freq; /* current frequency in Hz */
 127 static int radio_mode = RADIO_SCAN_MODE;
 128 static int search_dir = 0;
 129
 130 static int radio_status = FMRADIO_OFF;
 131 static bool in_screen = false;
 132
 133 #define MAX_PRESETS 64
 134 static bool presets_loaded = false, presets_changed = false;
 135 static struct fmstation presets[MAX_PRESETS];
 136
 137 static char filepreset[MAX_PATH]; /* preset filename variable */
 138
 139 static int num_presets = 0; /* The number of presets in the preset list */
 140
 141 static void radio_save_presets(void);
 142 static int handle_radio_presets(void);
 143 static bool radio_menu(void);
 144 static int radio_add_preset(void);
 145 static int save_preset_list(void);
 146 static int load_preset_list(void);
 147 static int clear_preset_list(void);
 148
 149 static int scan_presets(void *viewports);
 150
 151 /* Function to manipulate all yesno dialogues.
 152    This function needs the output text as an argument. */
 153 static bool yesno_pop(const char* text)
 154 {
 155     int i;
 156     const char *lines[]={text};
 157     const struct text_message message={lines, 1};
 158     bool ret = (gui_syncyesno_run(&message,NULL,NULL)== YESNO_YES);
 159     FOR_NB_SCREENS(i)
 160         screens[i].clear_viewport();
 161     return ret;
 162 }
 163
 164 void radio_init(void)
 165 {
 166     tuner_init();
 167     radio_stop();
 168 }
 169
 170 int get_radio_status(void)
 171 {
 172     return radio_status;
 173 }
 174
 175 bool in_radio_screen(void)
 176 {
 177     return in_screen;
 178 }
 179
 180 /* TODO: Move some more of the control functionality to firmware
 181          and clean up the mess */
 182
 183 /* secret flag for starting paused - prevents unmute */
 184 #define FMRADIO_START_PAUSED 0x8000
 185 void radio_start(void)
 186 {
 187     const struct fm_region_data *fmr;
 188     bool start_paused;
 189
 190     if(radio_status == FMRADIO_PLAYING)
 191         return;
 192
 193     fmr = &fm_region_data[global_settings.fm_region];
 194
 195     start_paused = radio_status & FMRADIO_START_PAUSED;
 196     /* clear flag before any yielding */
 197     radio_status &= ~FMRADIO_START_PAUSED;
 198
 199     if(radio_status == FMRADIO_OFF)
 200         tuner_power(true);
 201
 202     curr_freq = global_status.last_frequency * fmr->freq_step + fmr->freq_min;
 203
 204     tuner_set(RADIO_SLEEP, 0); /* wake up the tuner */
 205
 206     if(radio_status == FMRADIO_OFF)
 207     {
 208 #ifdef HAVE_RADIO_REGION
 209         tuner_set(RADIO_REGION, global_settings.fm_region);
 210 #endif
 211         tuner_set(RADIO_FORCE_MONO, global_settings.fm_force_mono);
 212     }
 213
 214     tuner_set(RADIO_FREQUENCY, curr_freq);
 215
 216 #ifdef HAVE_RADIO_MUTE_TIMEOUT
 217     {
 218         unsigned long mute_timeout = current_tick + HZ;
 219         if (radio_status != FMRADIO_OFF)
 220         {
 221             /* paused */
 222             mute_timeout += HZ;
 223         }
 224
 225         while(!tuner_get(RADIO_STEREO) && !tuner_get(RADIO_TUNED))
 226         {
 227             if(TIME_AFTER(current_tick, mute_timeout))
 228                  break;
 229             yield();
 230         }
 231     }
 232 #endif
 233
 234     /* keep radio from sounding initially */
 235     if(!start_paused)
 236         tuner_set(RADIO_MUTE, 0);
 237
 238     radio_status = FMRADIO_PLAYING;
 239 } /* radio_start */
 240
 241 void radio_pause(void)
 242 {
 243     if(radio_status == FMRADIO_PAUSED)
 244         return;
 245
 246     if(radio_status == FMRADIO_OFF)
 247     {
 248         radio_status |= FMRADIO_START_PAUSED;
 249         radio_start();
 250     }
 251
 252     tuner_set(RADIO_MUTE, 1);
 253     tuner_set(RADIO_SLEEP, 1);
 254
 255     radio_status = FMRADIO_PAUSED;
 256 } /* radio_pause */
 257
 258 void radio_stop(void)
 259 {
 260     if(radio_status == FMRADIO_OFF)
 261         return;
 262
 263     tuner_set(RADIO_MUTE, 1);
 264     tuner_set(RADIO_SLEEP, 1); /* low power mode, if available */
 265     radio_status = FMRADIO_OFF;
 266     tuner_power(false); /* status update, power off if avail. */
 267 } /* radio_stop */
 268
 269 bool radio_hardware_present(void)
 270 {
 271     return tuner_get(RADIO_PRESENT);
 272 }
 273
 274 /* Keep freq on the grid for the current region */
 275 static int snap_freq_to_grid(int freq)
 276 {
 277     const struct fm_region_data * const fmr =
 278         &fm_region_data[global_settings.fm_region];
 279
 280     /* Range clamp if out of range or just round to nearest */
 281     if (freq < fmr->freq_min)
 282         freq = fmr->freq_min;
 283     else if (freq > fmr->freq_max)
 284         freq = fmr->freq_max;
 285     else
 286         freq = (freq - fmr->freq_min + fmr->freq_step/2) /
 287                 fmr->freq_step * fmr->freq_step + fmr->freq_min;
 288
 289     return freq;
 290 }
 291
 292 /* Find a matching preset to freq */
 293 static int find_preset(int freq)
 294 {
 295     int i;
 296     if(num_presets < 1)
 297         return -1;
 298     for(i = 0;i < MAX_PRESETS;i++)
 299     {
 300         if(freq == presets[i].frequency)
 301             return i;
 302     }
 303
 304     return -1;
 305 }
 306
 307 /* Return the closest preset encountered in the search direction with
 308    wraparound. */
 309 static int find_closest_preset(int freq, int direction)
 310 {
 311     int i;
 312     int lowpreset = 0;
 313     int highpreset = 0;
 314     int closest = -1;
 315
 316     if (direction == 0) /* direction == 0 isn't really used */
 317         return 0;
 318
 319     for (i = 0; i < num_presets; i++)
 320     {
 321         int f = presets[i].frequency;
 322         if (f == freq)
 323             return i; /* Exact match = stop */
 324
 325         /* remember the highest and lowest presets for wraparound */
 326         if (f < presets[lowpreset].frequency)
 327             lowpreset = i;
 328         if (f > presets[highpreset].frequency)
 329             highpreset = i;
 330
 331         /* find the closest preset in the given direction */
 332         if (direction > 0 && f > freq)
 333         {
 334             if (closest < 0 || f < presets[closest].frequency)
 335                 closest = i;
 336         }
 337         else if (direction < 0 && f < freq)
 338         {
 339             if (closest < 0 || f > presets[closest].frequency)
 340                 closest = i;
 341         }
 342     }
 343
 344     if (closest < 0)
 345     {
 346         /* no presets in the given direction */
 347         /* wrap around depending on direction */
 348         if (direction < 0)
 349             closest = highpreset;
 350         else
 351             closest = lowpreset;
 352     }
 353
 354     return closest;
 355 }
 356
 357 static void remember_frequency(void)
 358 {
 359     const struct fm_region_data * const fmr =
 360         &fm_region_data[global_settings.fm_region];
 361     global_status.last_frequency = (curr_freq - fmr->freq_min)
 362                                    / fmr->freq_step;
 363     status_save();
 364 }
 365
 366 static void next_preset(int direction)
 367 {
 368     if (num_presets < 1)
 369         return;
 370
 371     if (curr_preset == -1)
 372         curr_preset = find_closest_preset(curr_freq, direction);
 373     else
 374         curr_preset = (curr_preset + direction + num_presets) % num_presets;
 375
 376     /* Must stay on the current grid for the region */
 377     curr_freq = snap_freq_to_grid(presets[curr_preset].frequency);
 378
 379     tuner_set(RADIO_FREQUENCY, curr_freq);
 380     remember_frequency();
 381 }
 382
 383 /* Step to the next or previous frequency */
 384 static int step_freq(int freq, int direction)
 385 {
 386     const struct fm_region_data * const fmr =
 387         &fm_region_data[global_settings.fm_region];
 388
 389     freq += direction*fmr->freq_step;
 390
 391     /* Wrap first or snapping to grid will not let us on the band extremes */
 392     if (freq > fmr->freq_max)
 393         freq = direction > 0 ? fmr->freq_min : fmr->freq_max;
 394     else if (freq < fmr->freq_min)
 395         freq = direction < 0 ? fmr->freq_max : fmr->freq_min;
 396     else
 397         freq = snap_freq_to_grid(freq);
 398
 399     return freq;
 400 }
 401
 402 /* Step to the next or previous station */
 403 static void next_station(int direction)
 404 {
 405     if (direction != 0 && radio_mode != RADIO_SCAN_MODE)
 406     {
 407         next_preset(direction);
 408         return;
 409     }
 410
 411     curr_freq = step_freq(curr_freq, direction);
 412
 413     if (radio_status == FMRADIO_PLAYING)
 414         tuner_set(RADIO_MUTE, 1);
 415
 416     tuner_set(RADIO_FREQUENCY, curr_freq);
 417
 418     if (radio_status == FMRADIO_PLAYING)
 419         tuner_set(RADIO_MUTE, 0);
 420
 421     curr_preset = find_preset(curr_freq);
 422     remember_frequency();
 423 }
 424
 425 /* Ends an in-progress search */
 426 static void end_search(void)
 427 {
 428     if (search_dir != 0 && radio_status == FMRADIO_PLAYING)
 429         tuner_set(RADIO_MUTE, 0);
 430     search_dir = 0;
 431 }
 432
 433 /* Speak a frequency. */
 434 static void talk_freq(int freq, bool enqueue)
 435 {
 436     freq /= 10000;
 437     talk_number(freq / 100, enqueue);
 438     talk_id(LANG_POINT, true);
 439     talk_number(freq % 100 / 10, true);
 440     if (freq % 10)
 441         talk_number(freq % 10, true);
 442 }
 443
 444 /* Speak a preset by number or by spelling its name, depending on settings. */
 445 static void talk_preset(int preset, bool fallback, bool enqueue)
 446 {
 447     if (global_settings.talk_file == 1) /* number */
 448         talk_number(preset + 1, enqueue);
 449     else
 450     { /* spell */
 451         if(presets[preset].name[0])
 452             talk_spell(presets[preset].name, enqueue);
 453         else if(fallback)
 454              talk_freq(presets[preset].frequency, enqueue);
 455     }
 456 }
 457
 458 static void fms_restore(struct viewport vp[NB_SCREENS])
 459 {
 460     struct screen *display;
 461     int i;
 462     FOR_NB_SCREENS(i)
 463     {
 464         display = &screens[i];
 465         display->set_viewport(&vp[i]);
 466         display->clear_viewport();
 467         display->update_viewport();
 468     }
 469 }
 470
 471 int radio_screen(void)
 472 {
 473     char buf[MAX_PATH];
 474     bool done = false;
 475     int ret_val = GO_TO_ROOT;
 476     int button;
 477     int i;
 478     bool stereo = false, last_stereo = false;
 479     int fh;
 480     int top_of_screen = 0;
 481     bool update_screen = true;
 482     bool screen_freeze = false;
 483     bool keep_playing = false;
 484     bool talk = false;
 485 #ifdef FM_RECORD_DBLPRE
 486     int lastbutton = BUTTON_NONE;
 487     unsigned long rec_lastclick = 0;
 488 #endif
 489 #if CONFIG_CODEC != SWCODEC
 490     bool have_recorded = false;
 491     int timeout = current_tick + HZ/10;
 492     unsigned int seconds = 0;
 493     unsigned int last_seconds = 0;
 494     int hours, minutes;
 495     struct audio_recording_options rec_options;
 496 #endif /* CONFIG_CODEC != SWCODEC */
 497 #ifndef HAVE_NOISY_IDLE_MODE
 498     int button_timeout = current_tick + (2*HZ);
 499 #endif
 500     struct viewport vp[NB_SCREENS];
 501 #ifdef HAVE_BUTTONBAR
 502     struct gui_buttonbar buttonbar;
 503     gui_buttonbar_init(&buttonbar);
 504     gui_buttonbar_set_display(&buttonbar, &(screens[SCREEN_MAIN]) );
 505 #endif
 506
 507     /* change status to "in screen" */
 508     in_screen = true;
 509
 510     /* always display status bar in radio screen for now */
 511     FOR_NB_SCREENS(i)
 512     {
 513         viewport_set_defaults(&vp[i], i);
 514 #ifdef HAVE_BUTTONBAR
 515         if (global_settings.buttonbar)
 516             vp[i].height -= BUTTONBAR_HEIGHT;
 517 #endif
 518     }
 519     fms_restore(vp);
 520
 521     fh = font_get(FONT_UI)->height;
 522
 523     /* Adjust for font size, trying to center the information vertically */
 524     if(fh < 10)
 525         top_of_screen = 1;
 526
 527     if(num_presets <= 0)
 528     {
 529         radio_load_presets(global_settings.fmr_file);
 530     }
 531
 532     if(radio_status == FMRADIO_OFF)
 533         audio_stop();
 534 #ifndef SIMULATOR
 535
 536 #if CONFIG_CODEC != SWCODEC
 537     if(rec_create_directory() > 0)
 538         have_recorded = true;
 539
 540     audio_init_recording(talk_get_bufsize());
 541
 542     sound_settings_apply();
 543     /* Yes, we use the D/A for monitoring */
 544     peak_meter_playback(true);
 545
 546     peak_meter_enabled = true;
 547
 548     rec_init_recording_options(&rec_options);
 549     rec_options.rec_source = AUDIO_SRC_LINEIN;
 550     rec_set_recording_options(&rec_options);
 551
 552     audio_set_recording_gain(sound_default(SOUND_LEFT_GAIN),
 553             sound_default(SOUND_RIGHT_GAIN), AUDIO_GAIN_LINEIN);
 554
 555 #endif /* CONFIG_CODEC != SWCODEC */
 556 #endif /* ndef SIMULATOR */
 557
 558     /* turn on radio */
 559 #if CONFIG_CODEC == SWCODEC
 560     audio_set_input_source(AUDIO_SRC_FMRADIO,
 561                            (radio_status == FMRADIO_PAUSED) ?
 562                                SRCF_FMRADIO_PAUSED : SRCF_FMRADIO_PLAYING);
 563 #else
 564     if (radio_status == FMRADIO_OFF)
 565         radio_start();
 566 #endif
 567
 568    if(num_presets < 1 && yesno_pop(ID2P(LANG_FM_FIRST_AUTOSCAN)))
 569         scan_presets(vp);
 570
 571     curr_preset = find_preset(curr_freq);
 572     if(curr_preset != -1)
 573          radio_mode = RADIO_PRESET_MODE;
 574
 575 #ifdef HAVE_BUTTONBAR
 576     gui_buttonbar_set(&buttonbar, str(LANG_BUTTONBAR_MENU),
 577         str(LANG_PRESET), str(LANG_FM_BUTTONBAR_RECORD));
 578 #endif
 579
 580 #ifndef HAVE_NOISY_IDLE_MODE
 581     cpu_idle_mode(true);
 582 #endif
 583
 584     while(!done)
 585     {
 586         if(search_dir != 0)
 587         {
 588             curr_freq = step_freq(curr_freq, search_dir);
 589             update_screen = true;
 590
 591             if(tuner_set(RADIO_SCAN_FREQUENCY, curr_freq))
 592             {
 593                 curr_preset = find_preset(curr_freq);
 594                 remember_frequency();
 595                 end_search();
 596                 talk = true;
 597             }
 598             trigger_cpu_boost();
 599         }
 600
 601         if (!update_screen)
 602         {
 603             cancel_cpu_boost();
 604         }
 605
 606 #if CONFIG_CODEC != SWCODEC
 607         /* TODO: Can we timeout at HZ when recording since peaks aren't
 608            displayed? This should quiet recordings too. */
 609         button = get_action(CONTEXT_FM,
 610             update_screen ? TIMEOUT_NOBLOCK : HZ / PEAK_METER_FPS);
 611 #else
 612         button = get_action(CONTEXT_FM,
 613             update_screen ? TIMEOUT_NOBLOCK : HZ);
 614 #endif
 615
 616 #ifndef HAVE_NOISY_IDLE_MODE
 617         if (button != ACTION_NONE)
 618         {
 619             cpu_idle_mode(false);
 620             button_timeout = current_tick + (2*HZ);
 621         }
 622 #endif
 623         switch(button)
 624         {
 625              case ACTION_FM_STOP:
 626 #if CONFIG_CODEC != SWCODEC && !defined(SIMULATOR)
 627                 if(audio_status() == AUDIO_STATUS_RECORD)
 628                 {
 629                     audio_stop();
 630                 }
 631                 else
 632 #endif
 633                 {
 634                     done = true;
 635                     if(presets_changed)
 636                     {
 637                         if(yesno_pop(ID2P(LANG_FM_SAVE_CHANGES)))
 638                         {
 639                             if(filepreset[0] == '\0')
 640                                 save_preset_list();
 641                             else
 642                                 radio_save_presets();
 643                         }
 644                     }
 645                     /* Clear the preset list on exit. */
 646                     clear_preset_list();
 647                 }
 648                 update_screen = true;
 649                 break;
 650
 651 #ifdef FM_RECORD
 652             case ACTION_FM_RECORD:
 653 #ifdef FM_RECORD_DBLPRE
 654                 if (lastbutton != ACTION_FM_RECORD_DBLPRE)
 655                 {
 656                     rec_lastclick = 0;
 657                     break;
 658                 }
 659                 if (current_tick - rec_lastclick > HZ/2)
 660                 {
 661                     rec_lastclick = current_tick;
 662                     break;
 663                 }
 664 #endif /* FM_RECORD_DBLPRE */
 665 #ifndef SIMULATOR
 666                 if(audio_status() == AUDIO_STATUS_RECORD)
 667                 {
 668                     rec_command(RECORDING_CMD_START_NEWFILE);
 669                     update_screen = true;
 670                 }
 671                 else
 672                 {
 673                     have_recorded = true;
 674                     rec_command(RECORDING_CMD_START);
 675                     update_screen = true;
 676                 }
 677 #endif /* SIMULATOR */
 678                 last_seconds = 0;
 679                 break;
 680 #endif /* #ifdef FM_RECORD */
 681
 682             case ACTION_FM_EXIT:
 683 #if CONFIG_CODEC != SWCODEC && !defined(SIMULATOR)
 684                 if(audio_status() == AUDIO_STATUS_RECORD)
 685                     audio_stop();
 686 #endif
 687                 keep_playing = true;
 688                 done = true;
 689                 ret_val = GO_TO_ROOT;
 690                 if(presets_changed)
 691                 {
 692                     if(yesno_pop(ID2P(LANG_FM_SAVE_CHANGES)))
 693                     {
 694                         if(filepreset[0] == '\0')
 695                             save_preset_list();
 696                         else
 697                             radio_save_presets();
 698                     }
 699                 }
 700
 701                 /* Clear the preset list on exit. */
 702                 clear_preset_list();
 703
 704                 break;
 705
 706             case ACTION_STD_PREV:
 707             case ACTION_STD_NEXT:
 708                 next_station(button == ACTION_STD_PREV ? -1 : 1);
 709                 end_search();
 710                 update_screen = true;
 711                 talk = true;
 712                 break;
 713
 714             case ACTION_STD_PREVREPEAT:
 715             case ACTION_STD_NEXTREPEAT:
 716             {
 717                 int dir = search_dir;
 718                 search_dir = button == ACTION_STD_PREVREPEAT ? -1 : 1;
 719                 if (radio_mode != RADIO_SCAN_MODE)
 720                 {
 721                     next_preset(search_dir);
 722                     end_search();
 723                     update_screen = true;
 724                     talk = true;
 725                 }
 726                 else if (dir == 0)
 727                 {
 728                     /* Starting auto scan */
 729                     tuner_set(RADIO_MUTE, 1);
 730                     update_screen = true;
 731                 }
 732                 break;
 733                 }
 734
 735             case ACTION_SETTINGS_INC:
 736             case ACTION_SETTINGS_INCREPEAT:
 737                 global_settings.volume++;
 738                 setvol();
 739                 update_screen = true;
 740                 break;
 741
 742             case ACTION_SETTINGS_DEC:
 743             case ACTION_SETTINGS_DECREPEAT:
 744                 global_settings.volume--;
 745                 setvol();
 746                 update_screen = true;
 747                 break;
 748
 749             case ACTION_FM_PLAY:
 750                 if (radio_status == FMRADIO_PLAYING)
 751                     radio_pause();
 752                 else
 753                     radio_start();
 754
 755                 update_screen = true;
 756                 talk = false;
 757                 talk_shutup();
 758                 break;
 759
 760             case ACTION_FM_MENU:
 761                 FOR_NB_SCREENS(i)
 762                 {
 763                     screens[i].scroll_stop(&vp[i]);
 764                 }
 765                 radio_menu();
 766                 curr_preset = find_preset(curr_freq);
 767                 fms_restore(vp);
 768 #ifdef HAVE_BUTTONBAR
 769                 gui_buttonbar_set(&buttonbar, str(LANG_BUTTONBAR_MENU),
 770                                   str(LANG_PRESET),
 771                                   str(LANG_FM_BUTTONBAR_RECORD));
 772 #endif
 773                 update_screen = true;
 774                 break;
 775
 776 #ifdef FM_PRESET
 777             case ACTION_FM_PRESET:
 778                 if(num_presets < 1)
 779                 {
 780                     splash(HZ, ID2P(LANG_FM_NO_PRESETS));
 781                     update_screen = true;
 782                     fms_restore(vp);
 783
 784                     break;
 785                 }
 786                 FOR_NB_SCREENS(i)
 787                     screens[i].scroll_stop(&vp[i]);
 788                 handle_radio_presets();
 789                 fms_restore(vp);
 790 #ifdef HAVE_BUTTONBAR
 791                 gui_buttonbar_set(&buttonbar,
 792                                   str(LANG_BUTTONBAR_MENU),
 793                                   str(LANG_PRESET),
 794                                   str(LANG_FM_BUTTONBAR_RECORD));
 795 #endif
 796                 update_screen = true;
 797                 break;
 798 #endif /* FM_PRESET */
 799
 800 #ifdef HAVE_QUICKSCREEN
 801             case ACTION_FM_QUICKSCREEN:
 802             {
 803                 if (quick_screen_quick(button))
 804                 {
 805                     done = true;
 806                     break;
 807                 }
 808                 fms_restore(vp);
 809                 update_screen = true;
 810             }
 811             break;
 812 #endif
 813 #ifdef FM_FREEZE
 814             case ACTION_FM_FREEZE:
 815                 if(!screen_freeze)
 816                 {
 817                     splash(HZ, str(LANG_FM_FREEZE));
 818                     screen_freeze = true;
 819                 }
 820                 else
 821                 {
 822                     update_screen = true;
 823                     screen_freeze = false;
 824                 }
 825                 break;
 826 #endif /* FM_FREEZE */
 827
 828             case SYS_USB_CONNECTED:
 829 #if CONFIG_CODEC != SWCODEC
 830                 /* Only accept USB connection when not recording */
 831                 if(audio_status() != AUDIO_STATUS_RECORD)
 832 #endif
 833                 {
 834                     default_event_handler(SYS_USB_CONNECTED);
 835                     screen_freeze = true; /* Cosmetic: makes sure the
 836                                              radio screen doesn't redraw */
 837                     done = true;
 838                 }
 839                 break;
 840
 841 #ifdef FM_MODE
 842            case ACTION_FM_MODE:
 843                 if(radio_mode == RADIO_SCAN_MODE)
 844                 {
 845                     /* Force scan mode if there are no presets. */
 846                     if(num_presets > 0)
 847                         radio_mode = RADIO_PRESET_MODE;
 848                 }
 849                 else
 850                     radio_mode = RADIO_SCAN_MODE;
 851                 update_screen = true;
 852                 cond_talk_ids_fq(radio_mode ?
 853                                  LANG_PRESET : LANG_RADIO_SCAN_MODE);
 854                 talk = true;
 855                 break;
 856 #endif /* FM_MODE */
 857
 858 #ifdef FM_NEXT_PRESET
 859             case ACTION_FM_NEXT_PRESET:
 860                 next_preset(1);
 861                 end_search();
 862                 update_screen = true;
 863                 talk = true;
 864                 break;
 865 #endif
 866
 867 #ifdef FM_PREV_PRESET
 868             case ACTION_FM_PREV_PRESET:
 869                 next_preset(-1);
 870                 end_search();
 871                 update_screen = true;
 872                 talk = true;
 873                 break;
 874 #endif
 875
 876             default:
 877                 default_event_handler(button);
 878 #ifdef HAVE_RDS_CAP
 879                 if (tuner_get(RADIO_EVENT))
 880                     update_screen = true;
 881 #endif
 882                 if (!tuner_get(RADIO_PRESENT))
 883                 {
 884 #if CONFIG_CODEC != SWCODEC && !defined(SIMULATOR)
 885                     if(audio_status() == AUDIO_STATUS_RECORD)
 886                         audio_stop();
 887 #endif
 888                     keep_playing = false;
 889                     done = true;
 890                     ret_val = GO_TO_ROOT;
 891                     if(presets_changed)
 892                     {
 893                         if(yesno_pop(ID2P(LANG_FM_SAVE_CHANGES)))
 894                         {
 895                             if(filepreset[0] == '\0')
 896                                 save_preset_list();
 897                             else
 898                                 radio_save_presets();
 899                         }
 900                     }
 901
 902                     /* Clear the preset list on exit. */
 903                     clear_preset_list();
 904                 }
 905                 break;
 906         } /*switch(button)*/
 907
 908 #ifdef FM_RECORD_DBLPRE
 909         if (button != ACTION_NONE)
 910             lastbutton = button;
 911 #endif
 912
 913 #if CONFIG_CODEC != SWCODEC
 914         peak_meter_peek();
 915 #endif
 916
 917         if(!screen_freeze)
 918         {
 919             /* Only display the peak meter when not recording */
 920 #if CONFIG_CODEC != SWCODEC
 921             if(!audio_status())
 922             {
 923                 FOR_NB_SCREENS(i)
 924                 {
 925                     screens[i].set_viewport(&vp[i]);
 926                     peak_meter_screen(&screens[i],0, fh*(top_of_screen + 4),fh);
 927                     screens[i].update_rect(0, fh*(top_of_screen + 4),
 928                                            screens[i].getwidth(), fh);
 929                 }
 930             }
 931
 932             if(TIME_AFTER(current_tick, timeout))
 933             {
 934                 timeout = current_tick + HZ;
 935 #else  /* SWCODEC */
 936             {
 937 #endif /* CONFIG_CODEC == SWCODEC */
 938
 939                 /* keep "mono" from always being displayed when paused */
 940                 if (radio_status != FMRADIO_PAUSED)
 941                 {
 942                     stereo = tuner_get(RADIO_STEREO) &&
 943                         !global_settings.fm_force_mono;
 944
 945                     if(stereo != last_stereo)
 946                     {
 947                         update_screen = true;
 948                         last_stereo = stereo;
 949                     }
 950                 }
 951             }
 952
 953 #if CONFIG_CODEC != SWCODEC && !defined(SIMULATOR)
 954             seconds = audio_recorded_time() / HZ;
 955             if (update_screen || seconds > last_seconds)
 956             {
 957                 last_seconds = seconds;
 958 #else
 959             if (update_screen)
 960             {
 961 #endif
 962                 int freq;
 963
 964                 FOR_NB_SCREENS(i)
 965                 {
 966                     screens[i].set_viewport(&vp[i]);
 967                 }
 968
 969                 snprintf(buf, 128, curr_preset >= 0 ? "%d. %s" : " ",
 970                          curr_preset + 1, presets[curr_preset].name);
 971
 972                 FOR_NB_SCREENS(i)
 973                     screens[i].puts_scroll(0, top_of_screen, buf);
 974
 975                 freq = curr_freq / 10000;
 976                 snprintf(buf, 128, str(LANG_FM_STATION),
 977                          freq / 100, freq % 100);
 978                 FOR_NB_SCREENS(i)
 979                     screens[i].puts_scroll(0, top_of_screen + 1, buf);
 980
 981                 FOR_NB_SCREENS(i)
 982                     screens[i].puts_scroll(0, top_of_screen + 2,
 983                                            stereo ? str(LANG_CHANNEL_STEREO) :
 984                                                     str(LANG_CHANNEL_MONO));
 985
 986                 snprintf(buf, 128, "%s %s", str(LANG_MODE),
 987                          radio_mode ? str(LANG_PRESET) :
 988                                       str(LANG_RADIO_SCAN_MODE));
 989                 FOR_NB_SCREENS(i)
 990                     screens[i].puts_scroll(0, top_of_screen + 3, buf);
 991 #ifndef SIMULATOR
 992 #ifdef HAVE_RDS_CAP
 993                 snprintf(buf, 128, "%s",tuner_get_rds_info(RADIO_RDS_NAME));
 994                 FOR_NB_SCREENS(i)
 995                     screens[i].puts_scroll(0, top_of_screen + 4, buf);
 996
 997                 snprintf(buf, 128, "%s",tuner_get_rds_info(RADIO_RDS_TEXT));
 998                 FOR_NB_SCREENS(i)
 999                     screens[i].puts_scroll(0, top_of_screen + 5, buf);
1000 #endif
1001 #endif /* SIMULATOR */
1002
1003 #if CONFIG_CODEC != SWCODEC
1004                 if(audio_status() == AUDIO_STATUS_RECORD)
1005                 {
1006                     hours = seconds / 3600;
1007                     minutes = (seconds - (hours * 3600)) / 60;
1008                     snprintf(buf, 32, "%s %02d:%02d:%02d",
1009                              str(LANG_RECORDING_TIME),
1010                              hours, minutes, seconds%60);
1011                     FOR_NB_SCREENS(i)
1012                         screens[i].puts_scroll(0, top_of_screen + 4, buf);
1013                 }
1014                 else
1015                 {
1016                     if(rec_options.rec_prerecord_time)
1017                     {
1018                         snprintf(buf, 32, "%s %02d",
1019                                  str(LANG_RECORD_PRERECORD), seconds%60);
1020                         FOR_NB_SCREENS(i)
1021                             screens[i].puts_scroll(0, top_of_screen + 4, buf);
1022                     }
1023                 }
1024 #endif /* CONFIG_CODEC != SWCODEC */
1025
1026                 FOR_NB_SCREENS(i)
1027                     screens[i].update_viewport();
1028 #ifdef HAVE_BUTTONBAR
1029                 gui_buttonbar_draw(&buttonbar);
1030 #endif
1031             }
1032         }
1033
1034         update_screen = false;
1035
1036         if (global_settings.talk_file && talk
1037             && radio_status == FMRADIO_PAUSED)
1038         {
1039             talk = false;
1040             bool enqueue = false;
1041             if (radio_mode == RADIO_SCAN_MODE)
1042             {
1043                 talk_freq(curr_freq, enqueue);
1044                 enqueue = true;
1045             }
1046             if (curr_preset >= 0)
1047                 talk_preset(curr_preset, radio_mode == RADIO_PRESET_MODE,
1048                             enqueue);
1049         }
1050
1051 #if CONFIG_CODEC != SWCODEC
1052         if(audio_status() & AUDIO_STATUS_ERROR)
1053         {
1054             done = true;
1055         }
1056 #endif
1057
1058 #ifndef HAVE_NOISY_IDLE_MODE
1059         if (TIME_AFTER(current_tick, button_timeout))
1060         {
1061             cpu_idle_mode(true);
1062         }
1063 #endif
1064     } /*while(!done)*/
1065
1066 #ifndef SIMULATOR
1067 #if CONFIG_CODEC != SWCODEC
1068     if(audio_status() & AUDIO_STATUS_ERROR)
1069     {
1070         splash(0, str(LANG_DISK_FULL));
1071         fms_restore(vp);
1072         audio_error_clear();
1073
1074         while(1)
1075         {
1076             button = get_action(CONTEXT_FM, TIMEOUT_BLOCK);
1077             if(button == ACTION_FM_STOP)
1078                 break;
1079         }
1080     }
1081
1082     audio_init_playback();
1083 #endif /* CONFIG_CODEC != SWCODEC */
1084
1085     sound_settings_apply();
1086 #endif /* SIMULATOR */
1087
1088     if(keep_playing)
1089     {
1090 /* Catch FMRADIO_PLAYING status for the sim. */
1091 #ifndef SIMULATOR
1092 #if CONFIG_CODEC != SWCODEC
1093         /* Enable the Left and right A/D Converter */
1094         audio_set_recording_gain(sound_default(SOUND_LEFT_GAIN),
1095                                  sound_default(SOUND_RIGHT_GAIN),
1096                                  AUDIO_GAIN_LINEIN);
1097         mas_codec_writereg(6, 0x4000);
1098 #endif
1099         end_search();
1100 #endif /* SIMULATOR */
1101     }
1102     else
1103     {
1104 #if CONFIG_CODEC == SWCODEC
1105         audio_set_input_source(AUDIO_SRC_PLAYBACK, SRCF_PLAYBACK);
1106 #else
1107         radio_stop();
1108 #endif
1109     }
1110
1111 #ifndef HAVE_NOISY_IDLE_MODE
1112     cpu_idle_mode(false);
1113 #endif
1114     FOR_NB_SCREENS(i)
1115     {
1116         screens[i].scroll_stop(&vp[i]);
1117         screens[i].set_viewport(NULL);
1118     }
1119     in_screen = false;
1120 #if CONFIG_CODEC != SWCODEC
1121     return have_recorded;
1122 #else
1123     return false;
1124 #endif
1125 } /* radio_screen */
1126
1127 static void radio_save_presets(void)
1128 {
1129     int fd;
1130     int i;
1131
1132     fd = creat(filepreset);
1133     if(fd >= 0)
1134     {
1135         for(i = 0;i < num_presets;i++)
1136         {
1137             fdprintf(fd, "%d:%s\n", presets[i].frequency, presets[i].name);
1138         }
1139         close(fd);
1140
1141         if(!strncasecmp(FMPRESET_PATH, filepreset, strlen(FMPRESET_PATH)))
1142             set_file(filepreset, global_settings.fmr_file, MAX_FILENAME);
1143         presets_changed = false;
1144     }
1145     else
1146     {
1147         splash(HZ, ID2P(LANG_FM_PRESET_SAVE_FAILED));
1148     }
1149 }
1150
1151 void radio_load_presets(char *filename)
1152 {
1153     int fd;
1154     int rc;
1155     char buf[128];
1156     char *freq;
1157     char *name;
1158     bool done = false;
1159     int f;
1160
1161     memset(presets, 0, sizeof(presets));
1162     num_presets = 0;
1163
1164     /* No Preset in configuration. */
1165     if(filename[0] == '\0')
1166     {
1167         filepreset[0] = '\0';
1168         return;
1169     }
1170     /* Temporary preset, loaded until player shuts down. */
1171     else if(filename[0] == '/')
1172         strlcpy(filepreset, filename, sizeof(filepreset));
1173     /* Preset from default directory. */
1174     else
1175         snprintf(filepreset, sizeof(filepreset), "%s/%s.fmr",
1176             FMPRESET_PATH, filename);
1177
1178     fd = open_utf8(filepreset, O_RDONLY);
1179     if(fd >= 0)
1180     {
1181         while(!done && num_presets < MAX_PRESETS)
1182         {
1183             rc = read_line(fd, buf, 128);
1184             if(rc > 0)
1185             {
1186                 if(settings_parseline(buf, &freq, &name))
1187                 {
1188                     f = atoi(freq);
1189                     if(f) /* For backwards compatibility */
1190                     {
1191                         struct fmstation * const fms = &presets[num_presets];
1192                         fms->frequency = f;
1193                         strlcpy(fms->name, name, MAX_FMPRESET_LEN+1);
1194                         num_presets++;
1195                     }
1196                 }
1197             }
1198             else
1199                 done = true;
1200         }
1201         close(fd);
1202     }
1203     else /* invalid file name? */
1204         filepreset[0] = '\0';
1205
1206     presets_loaded = num_presets > 0;
1207     presets_changed = false;
1208 }
1209
1210
1211 static int radio_add_preset(void)
1212 {
1213     char buf[MAX_FMPRESET_LEN + 1];
1214
1215     if(num_presets < MAX_PRESETS)
1216     {
1217         buf[0] = '\0';
1218
1219         if (!kbd_input(buf, MAX_FMPRESET_LEN + 1))
1220         {
1221             struct fmstation * const fms = &presets[num_presets];
1222             strcpy(fms->name, buf);
1223             fms->frequency = curr_freq;
1224             num_presets++;
1225             presets_changed = true;
1226             presets_loaded = num_presets > 0;
1227             return true;
1228         }
1229     }
1230     else
1231     {
1232         splash(HZ, ID2P(LANG_FM_NO_FREE_PRESETS));
1233     }
1234     return false;
1235 }
1236
1237 /* needed to know which preset we are edit/delete-ing */
1238 static int selected_preset = -1;
1239 static int radio_edit_preset(void)
1240 {
1241     char buf[MAX_FMPRESET_LEN + 1];
1242
1243     if (num_presets > 0)
1244     {
1245         struct fmstation * const fms = &presets[selected_preset];
1246
1247         strcpy(buf, fms->name);
1248
1249         if (!kbd_input(buf, MAX_FMPRESET_LEN + 1))
1250         {
1251             strcpy(fms->name, buf);
1252             presets_changed = true;
1253         }
1254     }
1255
1256     return 1;
1257 }
1258
1259 static int radio_delete_preset(void)
1260 {
1261     if (num_presets > 0)
1262     {
1263         struct fmstation * const fms = &presets[selected_preset];
1264
1265         if (selected_preset >= --num_presets)
1266             selected_preset = num_presets - 1;
1267
1268         memmove(fms, fms + 1, (uintptr_t)(fms + num_presets) -
1269                               (uintptr_t)fms);
1270
1271         if (curr_preset >= num_presets)
1272             --curr_preset;
1273     }
1274
1275      /* Don't ask to save when all presets are deleted. */
1276     presets_changed = num_presets > 0;
1277
1278     if (!presets_changed)
1279     {
1280         /* The preset list will be cleared, switch to Scan Mode. */
1281         radio_mode = RADIO_SCAN_MODE;
1282         curr_preset = -1;
1283         presets_loaded = false;
1284     }
1285
1286     return 1;
1287 }
1288
1289 static int load_preset_list(void)
1290 {
1291     return !rockbox_browse(FMPRESET_PATH, SHOW_FMR);
1292 }
1293
1294 static int save_preset_list(void)
1295 {
1296     if(num_presets > 0)
1297     {
1298         bool bad_file_name = true;
1299
1300         if(!dir_exists(FMPRESET_PATH)) /* Check if there is preset folder */
1301             mkdir(FMPRESET_PATH);
1302
1303         create_numbered_filename(filepreset, FMPRESET_PATH, "preset",
1304                                  ".fmr", 2 IF_CNFN_NUM_(, NULL));
1305
1306         while(bad_file_name)
1307         {
1308             if(!kbd_input(filepreset, sizeof(filepreset)))
1309             {
1310                 /* check the name: max MAX_FILENAME (20) chars */
1311                 char* p2;
1312                 char* p1;
1313                 int len;
1314                 p1 = strrchr(filepreset, '/');
1315                 p2 = p1;
1316                 while((p1) && (*p2) && (*p2 != '.'))
1317                     p2++;
1318                 len = (int)(p2-p1) - 1;
1319                 if((!p1) || (len > MAX_FILENAME) || (len == 0))
1320                 {
1321                     /* no slash, too long or too short */
1322                     splash(HZ, ID2P(LANG_INVALID_FILENAME));
1323                 }
1324                 else
1325                 {
1326                     /* add correct extension (easier to always write)
1327                        at this point, p2 points to 0 or the extension dot */
1328                     *p2 = '\0';
1329                     strcat(filepreset,".fmr");
1330                     bad_file_name = false;
1331                     radio_save_presets();
1332                 }
1333             }
1334             else
1335             {
1336                 /* user aborted */
1337                 return false;
1338             }
1339         }
1340     }
1341     else
1342         splash(HZ, ID2P(LANG_FM_NO_PRESETS));
1343
1344     return true;
1345 }
1346
1347 static int clear_preset_list(void)
1348 {
1349     /* Clear all the preset entries */
1350     memset(presets, 0, sizeof (presets));
1351
1352     num_presets = 0;
1353     presets_loaded = false;
1354     /* The preset list will be cleared switch to Scan Mode. */
1355     radio_mode = RADIO_SCAN_MODE;
1356     curr_preset = -1;
1357
1358     presets_changed = false; /* Don't ask to save when clearing the list. */
1359
1360     return true;
1361 }
1362
1363 MENUITEM_FUNCTION(radio_edit_preset_item, MENU_FUNC_CHECK_RETVAL,
1364                     ID2P(LANG_FM_EDIT_PRESET),
1365                     radio_edit_preset, NULL, NULL, Icon_NOICON);
1366 MENUITEM_FUNCTION(radio_delete_preset_item, MENU_FUNC_CHECK_RETVAL,
1367                     ID2P(LANG_FM_DELETE_PRESET),
1368                     radio_delete_preset, NULL, NULL, Icon_NOICON);
1369 static int radio_preset_callback(int action,
1370                                  const struct menu_item_ex *this_item)
1371 {
1372     if (action == ACTION_STD_OK)
1373         action = ACTION_EXIT_AFTER_THIS_MENUITEM;
1374     return action;
1375     (void)this_item;
1376 }
1377 MAKE_MENU(handle_radio_preset_menu, ID2P(LANG_PRESET),
1378             radio_preset_callback, Icon_NOICON, &radio_edit_preset_item,
1379             &radio_delete_preset_item);
1380 /* present a list of preset stations */
1381 static const char* presets_get_name(int selected_item, void *data,
1382                                     char *buffer, size_t buffer_len)
1383 {
1384     (void)data;
1385     struct fmstation *p = &presets[selected_item];
1386     if(p->name[0])
1387         return p->name;
1388     int freq = p->frequency / 10000;
1389     int frac = freq % 100;
1390     freq /= 100;
1391     snprintf(buffer, buffer_len,
1392              str(LANG_FM_DEFAULT_PRESET_NAME), freq, frac);
1393     return buffer;
1394 }
1395
1396 static int presets_speak_name(int selected_item, void * data)
1397 {
1398     (void)data;
1399     talk_preset(selected_item, true, false);
1400     return 0;
1401 }
1402
1403 static int handle_radio_presets(void)
1404 {
1405     struct gui_synclist lists;
1406     int result = 0;
1407     int action = ACTION_NONE;
1408 #ifdef HAVE_BUTTONBAR
1409     struct gui_buttonbar buttonbar;
1410 #endif
1411
1412     if(presets_loaded == false)
1413         return result;
1414
1415 #ifdef HAVE_BUTTONBAR
1416     gui_buttonbar_init(&buttonbar);
1417     gui_buttonbar_set_display(&buttonbar, &(screens[SCREEN_MAIN]) );
1418     gui_buttonbar_set(&buttonbar, str(LANG_FM_BUTTONBAR_ADD),
1419                                  str(LANG_FM_BUTTONBAR_EXIT),
1420                                  str(LANG_FM_BUTTONBAR_ACTION));
1421     gui_buttonbar_draw(&buttonbar);
1422 #endif
1423     gui_synclist_init(&lists, presets_get_name, NULL, false, 1, NULL);
1424     gui_synclist_set_title(&lists, str(LANG_PRESET), NOICON);
1425     gui_synclist_set_icon_callback(&lists, NULL);
1426     if(global_settings.talk_file)
1427         gui_synclist_set_voice_callback(&lists, presets_speak_name);
1428     gui_synclist_set_nb_items(&lists, num_presets);
1429     gui_synclist_select_item(&lists, curr_preset<0 ? 0 : curr_preset);
1430     gui_synclist_speak_item(&lists);
1431
1432     while (result == 0)
1433     {
1434         gui_synclist_draw(&lists);
1435         list_do_action(CONTEXT_STD, TIMEOUT_BLOCK,
1436                        &lists, &action, LIST_WRAP_UNLESS_HELD);
1437         switch (action)
1438         {
1439             case ACTION_STD_MENU:
1440                 if (radio_add_preset())
1441                 {
1442                     gui_synclist_set_nb_items(&lists, num_presets);
1443                     gui_synclist_select_item(&lists, num_presets - 1);
1444         }
1445                 break;
1446             case ACTION_STD_CANCEL:
1447                 result = 1;
1448                 break;
1449             case ACTION_STD_OK:
1450                 curr_preset = gui_synclist_get_sel_pos(&lists);
1451                 curr_freq = presets[curr_preset].frequency;
1452                 next_station(0);
1453                 remember_frequency();
1454                 result = 1;
1455                 break;
1456             case ACTION_F3:
1457             case ACTION_STD_CONTEXT:
1458                 selected_preset = gui_synclist_get_sel_pos(&lists);
1459                 do_menu(&handle_radio_preset_menu, NULL, NULL, false);
1460                 gui_synclist_set_nb_items(&lists, num_presets);
1461                 gui_synclist_select_item(&lists, selected_preset);
1462                 gui_synclist_speak_item(&lists);
1463                 break;
1464             default:
1465                 if(default_event_handler(action) == SYS_USB_CONNECTED)
1466                     result = 2;
1467         }
1468     }
1469     gui_synclist_scroll_stop(&lists);
1470     return result - 1;
1471 }
1472
1473 void toggle_mono_mode(bool mono)
1474 {
1475     tuner_set(RADIO_FORCE_MONO, mono);
1476 }
1477
1478 void set_radio_region(int region)
1479 {
1480 #ifdef HAVE_RADIO_REGION
1481     tuner_set(RADIO_REGION, region);
1482 #endif
1483     next_station(0);
1484     remember_frequency();
1485     (void)region;
1486 }
1487
1488 MENUITEM_SETTING(set_region, &global_settings.fm_region, NULL);
1489 MENUITEM_SETTING(force_mono, &global_settings.fm_force_mono, NULL);
1490
1491 #ifndef FM_MODE
1492 static char* get_mode_text(int selected_item, void * data, char *buffer)
1493 {
1494     (void)selected_item;
1495     (void)data;
1496     snprintf(buffer, MAX_PATH, "%s %s", str(LANG_MODE),
1497              radio_mode ? str(LANG_PRESET) :
1498                           str(LANG_RADIO_SCAN_MODE));
1499     return buffer;
1500 }
1501 static int toggle_radio_mode(void)
1502 {
1503     radio_mode = (radio_mode == RADIO_SCAN_MODE) ?
1504                  RADIO_PRESET_MODE : RADIO_SCAN_MODE;
1505     return 0;
1506 }
1507 MENUITEM_FUNCTION_DYNTEXT(radio_mode_item, 0,
1508                                  toggle_radio_mode, NULL,
1509                                  get_mode_text, NULL, NULL, NULL, Icon_NOICON);
1510 #endif
1511
1512 static int scan_presets(void *viewports)
1513 {
1514     bool do_scan = true;
1515     int i;
1516     struct viewport *vp = (struct viewport *)viewports;
1517
1518     FOR_NB_SCREENS(i)
1519         screens[i].set_viewport(vp?&vp[i]:NULL);
1520     if(num_presets > 0) /* Do that to avoid 2 questions. */
1521         do_scan = yesno_pop(ID2P(LANG_FM_CLEAR_PRESETS));
1522
1523     if(do_scan)
1524     {
1525         const struct fm_region_data * const fmr =
1526             &fm_region_data[global_settings.fm_region];
1527
1528         curr_freq = fmr->freq_min;
1529         num_presets = 0;
1530         memset(presets, 0, sizeof(presets));
1531
1532         tuner_set(RADIO_MUTE, 1);
1533
1534         while(curr_freq <= fmr->freq_max)
1535         {
1536             int freq, frac;
1537             if(num_presets >= MAX_PRESETS || action_userabort(TIMEOUT_NOBLOCK))
1538                 break;
1539
1540             freq = curr_freq / 10000;
1541             frac = freq % 100;
1542             freq /= 100;
1543
1544             splashf(0, str(LANG_FM_SCANNING), freq, frac);
1545
1546             if(tuner_set(RADIO_SCAN_FREQUENCY, curr_freq))
1547             {
1548                 /* add preset */
1549                 presets[num_presets].name[0] = '\0';
1550                 presets[num_presets].frequency = curr_freq;
1551                 num_presets++;
1552             }
1553
1554             curr_freq += fmr->freq_step;
1555         }
1556
1557         if (radio_status == FMRADIO_PLAYING)
1558             tuner_set(RADIO_MUTE, 0);
1559
1560         presets_changed = true;
1561
1562         FOR_NB_SCREENS(i)
1563         {
1564             screens[i].clear_viewport();
1565             screens[i].update_viewport();
1566         }
1567
1568         if(num_presets > 0)
1569         {
1570             curr_freq = presets[0].frequency;
1571             radio_mode = RADIO_PRESET_MODE;
1572             presets_loaded = true;
1573             next_station(0);
1574         }
1575         else
1576         {
1577             /* Wrap it to beginning or we'll be past end of band */
1578             presets_loaded = false;
1579             next_station(1);
1580         }
1581     }
1582     return true;
1583 }
1584
1585
1586 #ifdef HAVE_RECORDING
1587
1588 #if defined(HAVE_FMRADIO_REC) && CONFIG_CODEC == SWCODEC
1589 #define FM_RECORDING_SCREEN
1590 static int fm_recording_screen(void)
1591 {
1592     bool ret;
1593
1594     /* switch recording source to FMRADIO for the duration */
1595     int rec_source = global_settings.rec_source;
1596     global_settings.rec_source = AUDIO_SRC_FMRADIO;
1597     ret = recording_screen(true);
1598
1599     /* safe to reset as changing sources is prohibited here */
1600     global_settings.rec_source = rec_source;
1601
1602     return ret;
1603 }
1604
1605 #endif /* defined(HAVE_FMRADIO_REC) && CONFIG_CODEC == SWCODEC */
1606
1607 #if defined(HAVE_FMRADIO_REC) || CONFIG_CODEC != SWCODEC
1608 #define FM_RECORDING_SETTINGS
1609 static int fm_recording_settings(void)
1610 {
1611     bool ret = recording_menu(true);
1612
1613 #if CONFIG_CODEC != SWCODEC
1614     if (!ret)
1615     {
1616         struct audio_recording_options rec_options;
1617         rec_init_recording_options(&rec_options);
1618         rec_options.rec_source = AUDIO_SRC_LINEIN;
1619         rec_set_recording_options(&rec_options);
1620     }
1621 #endif
1622
1623     return ret;
1624 }
1625
1626 #endif /* defined(HAVE_FMRADIO_REC) || CONFIG_CODEC != SWCODEC */
1627 #endif /* HAVE_RECORDING */
1628
1629 #ifdef FM_RECORDING_SCREEN
1630 MENUITEM_FUNCTION(recscreen_item, 0, ID2P(LANG_RECORDING),
1631                     fm_recording_screen, NULL, NULL, Icon_Recording);
1632 #endif
1633 #ifdef FM_RECORDING_SETTINGS
1634 MENUITEM_FUNCTION(recsettings_item, 0, ID2P(LANG_RECORDING_SETTINGS),
1635                     fm_recording_settings, NULL, NULL, Icon_Recording);
1636 #endif
1637 #ifndef FM_PRESET
1638 MENUITEM_FUNCTION(radio_presets_item, 0, ID2P(LANG_PRESET),
1639                     handle_radio_presets, NULL, NULL, Icon_NOICON);
1640 #endif
1641 #ifndef FM_PRESET_ADD
1642 MENUITEM_FUNCTION(radio_addpreset_item, 0, ID2P(LANG_FM_ADD_PRESET),
1643                     radio_add_preset, NULL, NULL, Icon_NOICON);
1644 #endif
1645
1646
1647 MENUITEM_FUNCTION(presetload_item, 0, ID2P(LANG_FM_PRESET_LOAD),
1648                     load_preset_list, NULL, NULL, Icon_NOICON);
1649 MENUITEM_FUNCTION(presetsave_item, 0, ID2P(LANG_FM_PRESET_SAVE),
1650                     save_preset_list, NULL, NULL, Icon_NOICON);
1651 MENUITEM_FUNCTION(presetclear_item, 0, ID2P(LANG_FM_PRESET_CLEAR),
1652                     clear_preset_list, NULL, NULL, Icon_NOICON);
1653 MENUITEM_FUNCTION(scan_presets_item, MENU_FUNC_USEPARAM,
1654                     ID2P(LANG_FM_SCAN_PRESETS),
1655                     scan_presets, NULL, NULL, Icon_NOICON);
1656
1657 MAKE_MENU(radio_settings_menu, ID2P(LANG_FM_MENU), NULL,
1658             Icon_Radio_screen,
1659 #ifndef FM_PRESET
1660             &radio_presets_item,
1661 #endif
1662 #ifndef FM_PRESET_ADD
1663             &radio_addpreset_item,
1664 #endif
1665             &presetload_item, &presetsave_item, &presetclear_item,
1666             &force_mono,
1667 #ifndef FM_MODE
1668             &radio_mode_item,
1669 #endif
1670             &set_region, &sound_settings,
1671 #ifdef FM_RECORDING_SCREEN
1672             &recscreen_item,
1673 #endif
1674 #ifdef FM_RECORDING_SETTINGS
1675             &recsettings_item,
1676 #endif
1677             &scan_presets_item);
1678 /* main menu of the radio screen */
1679 static bool radio_menu(void)
1680 {
1681     return do_menu(&radio_settings_menu, NULL, NULL, false) ==
1682                                                             MENU_ATTACHED_USB;
1683 }
1684
1685 #endif