apps/menus/recording_menu.c

   1 /***************************************************************************
   2  *             __________               __   ___.
   3  *   Open      \______   \ ____   ____ |  | _\_ |__   _______  ___
   4  *   Source     |       _//  _ \_/ ___\|  |/ /| __ \ /  _ \  \/  /
   5  *   Jukebox    |    |   (  <_> )  \___|    < | \_\ (  <_> > <  <
   6  *   Firmware   |____|_  /\____/ \___  >__|_ \|___  /\____/__/\_ \
   7  *                     \/            \/     \/    \/            \/
   8  * $Id$
   9  *
  10  * Copyright (C) 2007 Jonathan Gordon
  11  *
  12  * All files in this archive are subject to the GNU General Public License.
  13  * See the file COPYING in the source tree root for full license agreement.
  14  *
  15  * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY
  16  * KIND, either express or implied.
  17  *
  18  ****************************************************************************/
  19
  20 #include "config.h"
  21 #include <stdio.h>
  22 #include <stdlib.h>
  23 #include <stdbool.h>
  24 #include "string.h"
  25 #include "system.h"
  26 #include "kernel.h"
  27 #include "lcd.h"
  28 #include "menu.h"
  29 #include "button.h"
  30 #include "mp3_playback.h"
  31 #include "settings.h"
  32 #include "statusbar.h"
  33 #include "screens.h"
  34 #include "icons.h"
  35 #ifdef HAVE_LCD_BITMAP
  36 #include "font.h"
  37 #include "scrollbar.h"
  38 #endif
  39 #include "lang.h"
  40 #include "sprintf.h"
  41 #include "talk.h"
  42 #include "misc.h"
  43 #include "sound.h"
  44 #ifdef HAVE_RECORDING
  45 #include "audio.h"
  46 #if CONFIG_TUNER
  47 #include "radio.h"
  48 #endif
  49 #endif
  50 #ifdef HAVE_RECORDING
  51 #include "peakmeter.h"
  52 #include "mas.h"
  53 #endif
  54 #include "splash.h"
  55 #if CONFIG_CODEC == SWCODEC
  56 #include "dsp.h"
  57 #include "menus/eq_menu.h"
  58 #ifdef HAVE_RECORDING
  59 #include "enc_config.h"
  60 #endif
  61 #include "general.h"
  62 #endif
  63 #include "action.h"
  64 #include "recording.h"
  65 #include "sound_menu.h"
  66 #include "option_select.h"
  67 #include "settings_list.h"
  68 #include "list.h"
  69 #include "viewport.h"
  70
  71 static bool no_source_in_menu = false;
  72 int recmenu_callback(int action,const struct menu_item_ex *this_item);
  73
  74 static int recsource_func(void)
  75 {
  76     int n_opts = REC_NUM_SOURCES;
  77
  78     static const struct opt_items names[AUDIO_NUM_SOURCES] = {
  79         HAVE_MIC_REC_([AUDIO_SRC_MIC]
  80             = { STR(LANG_RECORDING_SRC_MIC) },)
  81         HAVE_LINE_REC_([AUDIO_SRC_LINEIN]
  82             = { STR(LANG_LINE_IN) },)
  83         HAVE_SPDIF_REC_([AUDIO_SRC_SPDIF]
  84             = { STR(LANG_RECORDING_SRC_DIGITAL) },)
  85         HAVE_FMRADIO_REC_([AUDIO_SRC_FMRADIO]
  86             = { STR(LANG_FM_RADIO) },)
  87     };
  88
  89     /* caveat: assumes it's the last item! */
  90 #ifdef HAVE_FMRADIO_REC
  91     if (!radio_hardware_present())
  92         n_opts--;
  93 #endif
  94
  95     return set_option(str(LANG_RECORDING_SOURCE),
  96                       &global_settings.rec_source, INT, names,
  97                       n_opts, NULL );
  98 }
  99 MENUITEM_FUNCTION(recsource, 0, ID2P(LANG_RECORDING_SOURCE),
 100                     recsource_func, NULL, recmenu_callback, Icon_Menu_setting);
 101
 102 #if CONFIG_CODEC == SWCODEC
 103 /* Makes an options list from a source list of options and indexes */
 104 static void make_options_from_indexes(const struct opt_items *src_names,
 105                                       const long *src_indexes,
 106                                       int n_indexes,
 107                                       struct opt_items *dst_names)
 108 {
 109     while (--n_indexes >= 0)
 110         dst_names[n_indexes] = src_names[src_indexes[n_indexes]];
 111 } /* make_options_from_indexes */
 112
 113
 114 #endif /* CONFIG_CODEC == SWCODEC */
 115
 116 static int recfrequency_func(void)
 117 {
 118 #if CONFIG_CODEC == MAS3587F
 119     static const struct opt_items names[6] = {
 120         { "44.1kHz", TALK_ID(44, UNIT_KHZ) },
 121         { "48kHz", TALK_ID(48, UNIT_KHZ) },
 122         { "32kHz", TALK_ID(32, UNIT_KHZ) },
 123         { "22.05kHz", TALK_ID(22, UNIT_KHZ) },
 124         { "24kHz", TALK_ID(24, UNIT_KHZ) },
 125         { "16kHz", TALK_ID(16, UNIT_KHZ) }
 126     };
 127     return set_option(str(LANG_RECORDING_FREQUENCY),
 128                       &global_settings.rec_frequency, INT,
 129                       names, 6, NULL );
 130 #endif /* CONFIG_CODEC == MAS3587F */
 131
 132 #if CONFIG_CODEC == SWCODEC
 133     static const struct opt_items names[REC_NUM_FREQ] = {
 134         REC_HAVE_96_([REC_FREQ_96] = { "96kHz",     TALK_ID(96, UNIT_KHZ) },)
 135         REC_HAVE_88_([REC_FREQ_88] = { "88.2kHz",   TALK_ID(88, UNIT_KHZ) },)
 136         REC_HAVE_64_([REC_FREQ_64] = { "64kHz",     TALK_ID(64, UNIT_KHZ) },)
 137         REC_HAVE_48_([REC_FREQ_48] = { "48kHz",     TALK_ID(48, UNIT_KHZ) },)
 138         REC_HAVE_44_([REC_FREQ_44] = { "44.1kHz",   TALK_ID(44, UNIT_KHZ) },)
 139         REC_HAVE_32_([REC_FREQ_32] = { "32kHz",     TALK_ID(32, UNIT_KHZ) },)
 140         REC_HAVE_24_([REC_FREQ_24] = { "24kHz",     TALK_ID(24, UNIT_KHZ) },)
 141         REC_HAVE_22_([REC_FREQ_22] = { "22.05kHz",  TALK_ID(22, UNIT_KHZ) },)
 142         REC_HAVE_16_([REC_FREQ_16] = { "16kHz",     TALK_ID(16, UNIT_KHZ) },)
 143         REC_HAVE_12_([REC_FREQ_12] = { "12kHz",     TALK_ID(12, UNIT_KHZ) },)
 144         REC_HAVE_11_([REC_FREQ_11] = { "11.025kHz", TALK_ID(11, UNIT_KHZ) },)
 145         REC_HAVE_8_( [REC_FREQ_8 ] = { "8kHz",      TALK_ID( 8, UNIT_KHZ) },)
 146     };
 147
 148     struct opt_items opts[REC_NUM_FREQ];
 149     unsigned long    table[REC_NUM_FREQ];
 150     int              n_opts;
 151     int              rec_frequency;
 152     bool             ret;
 153
 154 #ifdef HAVE_SPDIF_REC
 155     if (global_settings.rec_source == REC_SRC_SPDIF)
 156     {
 157         /* Inform user that frequency follows the source's frequency */
 158         opts[0].string    = ID2P(LANG_SOURCE_FREQUENCY);
 159         opts[0].voice_id  = LANG_SOURCE_FREQUENCY;
 160         n_opts            = 1;
 161         rec_frequency     = 0;
 162     }
 163     else
 164 #endif
 165     {
 166         struct encoder_caps caps;
 167         struct encoder_config cfg;
 168
 169         cfg.rec_format = global_settings.rec_format;
 170         global_to_encoder_config(&cfg);
 171
 172         if (!enc_get_caps(&cfg, &caps, true))
 173             return false;
 174
 175         /* Construct samplerate menu based upon encoder settings */
 176         n_opts = make_list_from_caps32(REC_SAMPR_CAPS, NULL,
 177                                        caps.samplerate_caps, table);
 178
 179         if (n_opts == 0)
 180             return false; /* No common flags...?? */
 181
 182         make_options_from_indexes(names, table, n_opts, opts);
 183
 184         /* Find closest rate that the potentially restricted list
 185            comes to */
 186         make_list_from_caps32(REC_SAMPR_CAPS, rec_freq_sampr,
 187                               caps.samplerate_caps, table);
 188
 189         rec_frequency = round_value_to_list32(
 190                 rec_freq_sampr[global_settings.rec_frequency],
 191                 table, n_opts, false);
 192     }
 193
 194     ret = set_option(str(LANG_RECORDING_FREQUENCY),
 195                      &rec_frequency, INT, opts, n_opts, NULL );
 196
 197     if (!ret
 198         HAVE_SPDIF_REC_( && global_settings.rec_source != REC_SRC_SPDIF)
 199     )
 200     {
 201         /* Translate back to full index */
 202         global_settings.rec_frequency =
 203                     round_value_to_list32(table[rec_frequency],
 204                                           rec_freq_sampr,
 205                                           REC_NUM_FREQ,
 206                                           false);
 207     }
 208
 209     return ret;
 210 #endif /* CONFIG_CODEC == SWCODEC */
 211 } /* recfrequency */
 212 MENUITEM_FUNCTION(recfrequency, 0, ID2P(LANG_RECORDING_FREQUENCY),
 213                     recfrequency_func, NULL, NULL, Icon_Menu_setting);
 214
 215
 216 static int recchannels_func(void)
 217 {
 218     static const struct opt_items names[CHN_NUM_MODES] = {
 219         [CHN_MODE_STEREO] = { STR(LANG_CHANNEL_STEREO) },
 220         [CHN_MODE_MONO]   = { STR(LANG_CHANNEL_MONO)   }
 221     };
 222 #if CONFIG_CODEC == MAS3587F
 223     return set_option(str(LANG_CHANNELS),
 224                       &global_settings.rec_channels, INT,
 225                       names, CHN_NUM_MODES, NULL );
 226 #endif /* CONFIG_CODEC == MAS3587F */
 227
 228 #if CONFIG_CODEC == SWCODEC
 229     struct opt_items    opts[CHN_NUM_MODES];
 230     long                table[CHN_NUM_MODES];
 231     struct encoder_caps caps;
 232     struct encoder_config cfg;
 233     int                 n_opts;
 234     int                 rec_channels;
 235     bool                ret;
 236
 237     cfg.rec_format = global_settings.rec_format;
 238     global_to_encoder_config(&cfg);
 239
 240     if (!enc_get_caps(&cfg, &caps, true))
 241         return false;
 242
 243     n_opts = make_list_from_caps32(CHN_CAP_ALL, NULL,
 244                                    caps.channel_caps, table);
 245
 246     rec_channels = round_value_to_list32(global_settings.rec_channels,
 247                                          table, n_opts, false);
 248
 249     make_options_from_indexes(names, table, n_opts, opts);
 250
 251     ret = set_option(str(LANG_CHANNELS), &rec_channels,
 252                      INT, opts, n_opts, NULL );
 253
 254     if (!ret)
 255         global_settings.rec_channels = table[rec_channels];
 256
 257     return ret;
 258 #endif /* CONFIG_CODEC == SWCODEC */
 259 }
 260 MENUITEM_FUNCTION(recchannels, 0, ID2P(LANG_CHANNELS),
 261                     recchannels_func, NULL, NULL, Icon_Menu_setting);
 262
 263 #if CONFIG_CODEC == SWCODEC
 264
 265 static int recformat_func(void)
 266 {
 267     static const struct opt_items names[REC_NUM_FORMATS] = {
 268         [REC_FORMAT_AIFF]    = { STR(LANG_AFMT_AIFF)    },
 269         [REC_FORMAT_MPA_L3]  = { STR(LANG_AFMT_MPA_L3)  },
 270         [REC_FORMAT_WAVPACK] = { STR(LANG_AFMT_WAVPACK) },
 271         [REC_FORMAT_PCM_WAV] = { STR(LANG_AFMT_PCM_WAV) },
 272     };
 273
 274     int rec_format = global_settings.rec_format;
 275     bool res = set_option(str(LANG_RECORDING_FORMAT), &rec_format, INT,
 276                           names, REC_NUM_FORMATS, NULL );
 277
 278     if (rec_format != global_settings.rec_format)
 279     {
 280         global_settings.rec_format = rec_format;
 281         enc_global_settings_apply();
 282     }
 283
 284     return res;
 285 } /* recformat */
 286 MENUITEM_FUNCTION(recformat, 0, ID2P(LANG_RECORDING_FORMAT),
 287                     recformat_func, NULL, NULL, Icon_Menu_setting);
 288
 289 MENUITEM_FUNCTION(enc_global_config_menu_item, 0, ID2P(LANG_ENCODER_SETTINGS),
 290                     (int(*)(void))enc_global_config_menu,
 291                      NULL, NULL, Icon_Submenu);
 292
 293 #endif /* CONFIG_CODEC == SWCODEC */
 294
 295
 296 int recmenu_callback(int action,const struct menu_item_ex *this_item)
 297 {
 298     switch (action)
 299     {
 300         case ACTION_REQUEST_MENUITEM:
 301             if (this_item == &recsource && no_source_in_menu)
 302                 return ACTION_EXIT_MENUITEM;
 303             break;
 304     }
 305     return action;
 306 }
 307 #if CONFIG_CODEC == MAS3587F
 308 MENUITEM_SETTING(rec_quality, &global_settings.rec_quality, NULL);
 309 MENUITEM_SETTING(rec_editable, &global_settings.rec_editable, NULL);
 310 #endif
 311
 312 MENUITEM_SETTING(rec_split_type, &global_settings.rec_split_type, NULL);
 313 MENUITEM_SETTING(rec_split_method, &global_settings.rec_split_method, NULL);
 314 MENUITEM_SETTING(rec_timesplit, &global_settings.rec_timesplit, NULL);
 315 MENUITEM_SETTING(rec_sizesplit, &global_settings.rec_sizesplit, NULL);
 316 MAKE_MENU(filesplitoptionsmenu, ID2P(LANG_RECORD_TIMESPLIT), NULL, Icon_NOICON,
 317             &rec_split_method, &rec_split_type, &rec_timesplit, &rec_sizesplit);
 318
 319
 320 MENUITEM_SETTING(rec_prerecord_time, &global_settings.rec_prerecord_time, NULL);
 321
 322 static int clear_rec_directory(void)
 323 {
 324     strcpy(global_settings.rec_directory, REC_BASE_DIR);
 325     gui_syncsplash(HZ, str(LANG_RESET_DONE_CLEAR));
 326     return false;
 327 }
 328 MENUITEM_FUNCTION(clear_rec_directory_item, 0, ID2P(LANG_CLEAR_REC_DIR),
 329                   clear_rec_directory, NULL, NULL, Icon_Folder);
 330
 331 MENUITEM_SETTING(cliplight, &global_settings.cliplight, NULL);
 332
 333 #ifdef HAVE_AGC
 334 static int agc_preset_func(void)
 335 {
 336     static const struct opt_items names[] = {
 337         { STR(LANG_OFF) },
 338         { STR(LANG_AGC_SAFETY) },
 339         { STR(LANG_AGC_LIVE) },
 340         { STR(LANG_AGC_DJSET) },
 341         { STR(LANG_AGC_MEDIUM) },
 342         { STR(LANG_AGC_VOICE) },
 343     };
 344     if (global_settings.rec_source)
 345         return set_option(str(LANG_RECORD_AGC_PRESET),
 346                           &global_settings.rec_agc_preset_line,
 347                           INT, names, 6, NULL );
 348     else
 349         return set_option(str(LANG_RECORD_AGC_PRESET),
 350                           &global_settings.rec_agc_preset_mic,
 351                           INT, names, 6, NULL );
 352 }
 353
 354 static int agc_cliptime_func(void)
 355 {
 356     static const struct opt_items names[] = {
 357         { "200ms", TALK_ID(200, UNIT_MS) },
 358         { "400ms", TALK_ID(400, UNIT_MS) },
 359         { "600ms", TALK_ID(600, UNIT_MS) },
 360         { "800ms", TALK_ID(800, UNIT_MS) },
 361         { "1s", TALK_ID(1, UNIT_SEC) }
 362     };
 363     return set_option(str(LANG_RECORD_AGC_CLIPTIME),
 364                       &global_settings.rec_agc_cliptime,
 365                       INT, names, 5, NULL );
 366 }
 367 MENUITEM_FUNCTION(agc_preset, 0, ID2P(LANG_RECORD_AGC_PRESET),
 368                     agc_preset_func, NULL, NULL, Icon_Menu_setting);
 369 MENUITEM_FUNCTION(agc_cliptime, 0, ID2P(LANG_RECORD_AGC_CLIPTIME),
 370                     agc_cliptime_func, NULL, NULL, Icon_Menu_setting);
 371 #endif /* HAVE_AGC */
 372
 373 /** Rec trigger **/
 374 enum trigger_menu_option
 375 {
 376     TRIGGER_MODE,
 377     TRIGGER_TYPE,
 378     PRERECORD_TIME,
 379     START_THRESHOLD,
 380     START_DURATION,
 381     STOP_THRESHOLD,
 382     STOP_POSTREC,
 383     STOP_GAP,
 384     TRIG_OPTION_COUNT,
 385 };
 386
 387 static enum themable_icons trigger_get_icon(int selected_item, void * data)
 388 {
 389     (void)data;
 390     if ((selected_item % 2) == 0) /* header */
 391           return Icon_Menu_setting;
 392     return Icon_NOICON;
 393 }
 394
 395 static char * trigger_get_name(int selected_item, void * data,
 396                         char * buffer, size_t buffer_len)
 397 {
 398     const struct settings_list **settings =
 399             (const struct settings_list **)data;
 400     const struct settings_list *s = settings[selected_item / 2];
 401     if ((selected_item % 2) == 0) /* header */
 402         return P2STR(ID2P(s->lang_id));
 403     else
 404     {
 405         int temp;
 406         temp = option_value_as_int(s);
 407         if ((selected_item / 2 == START_THRESHOLD ||
 408              selected_item / 2 == STOP_THRESHOLD) &&
 409              temp == 0)
 410         {
 411             return str(LANG_OFF);
 412         }
 413         return option_get_valuestring(s, buffer, buffer_len, temp);
 414     }
 415 }
 416 static void trigger_speak_item(const struct settings_list *s, bool title)
 417 {
 418     int temp;
 419     if (!global_settings.talk_menu)
 420         return;
 421     temp = option_value_as_int(s);
 422     if (title)
 423         talk_id(s->lang_id, false);
 424     option_talk_value(s, temp, title?true:false);
 425 }
 426 int rectrigger(void)
 427 {
 428     struct viewport vp[NB_SCREENS];
 429     struct gui_synclist lists;
 430     int i, action = ACTION_REDRAW;
 431     bool done = false, changed = true;
 432     const struct settings_list *settings[TRIG_OPTION_COUNT];
 433
 434     int pm_y[NB_SCREENS];
 435     int trig_xpos[NB_SCREENS];
 436     int trig_ypos[NB_SCREENS];
 437     int trig_width[NB_SCREENS];
 438
 439     int old_start_thres_db = global_settings.rec_start_thres_db;
 440     int old_start_thres_linear = global_settings.rec_start_thres_linear;
 441     int old_start_duration = global_settings.rec_start_duration;
 442     int old_prerecord_time = global_settings.rec_prerecord_time;
 443     int old_stop_thres_db = global_settings.rec_stop_thres_db;
 444     int old_stop_thres_linear = global_settings.rec_stop_thres_linear;
 445     int old_stop_postrec = global_settings.rec_stop_postrec;
 446     int old_stop_gap = global_settings.rec_stop_gap;
 447     int old_trigger_mode = global_settings.rec_trigger_mode;
 448     int old_trigger_type = global_settings.rec_trigger_type;
 449
 450     FOR_NB_SCREENS(i)
 451     {
 452         screens[i].clear_display();
 453         screens[i].update();
 454         viewport_set_defaults(&vp[i], i);
 455         vp[i].height -= SYSFONT_HEIGHT*2;
 456         trig_xpos[i] = 0;
 457         trig_ypos[i] =  vp[i].y + vp[i].height;
 458         pm_y[i] = screens[i].height - SYSFONT_HEIGHT;
 459         trig_width[i] = screens[i].width;
 460     }
 461     /* TODO: what to do if there is < 4 lines on the screen? */
 462
 463     settings[TRIGGER_MODE] =
 464             find_setting(&global_settings.rec_trigger_mode, NULL);
 465     settings[TRIGGER_TYPE] =
 466             find_setting(&global_settings.rec_trigger_type, NULL);
 467     settings[PRERECORD_TIME] =
 468             find_setting(&global_settings.rec_prerecord_time, NULL);
 469     settings[START_DURATION] =
 470             find_setting(&global_settings.rec_start_duration, NULL);
 471     settings[STOP_POSTREC] =
 472             find_setting(&global_settings.rec_stop_postrec, NULL);
 473     settings[STOP_GAP] =
 474             find_setting(&global_settings.rec_stop_gap, NULL);
 475     if (global_settings.peak_meter_dbfs) /* show the dB settings */
 476     {
 477         settings[START_THRESHOLD] =
 478                 find_setting(&global_settings.rec_start_thres_db, NULL);
 479         settings[STOP_THRESHOLD] =
 480                 find_setting(&global_settings.rec_stop_thres_db, NULL);
 481     }
 482     else
 483     {
 484         settings[START_THRESHOLD] =
 485                 find_setting(&global_settings.rec_start_thres_linear, NULL);
 486         settings[STOP_THRESHOLD] =
 487                 find_setting(&global_settings.rec_stop_thres_linear, NULL);
 488     }
 489     gui_synclist_init(&lists, trigger_get_name, settings, false, 2, vp);
 490     gui_synclist_set_nb_items(&lists, TRIG_OPTION_COUNT*2);
 491     gui_synclist_set_icon_callback(&lists, trigger_get_icon);
 492     /* restart trigger with new values */
 493     settings_apply_trigger();
 494     peak_meter_trigger (global_settings.rec_trigger_mode != TRIG_MODE_OFF);
 495
 496     trigger_speak_item(settings[0], true);
 497
 498     while (!done)
 499     {
 500         if (changed)
 501         {
 502             gui_synclist_draw(&lists);
 503             gui_syncstatusbar_draw(&statusbars, true);
 504             peak_meter_trigger(global_settings.rec_trigger_mode!=TRIG_OFF);
 505             settings_apply_trigger();
 506             changed = false;
 507         }
 508
 509         peak_meter_draw_trig(trig_xpos, trig_ypos, trig_width, NB_SCREENS);
 510         action = peak_meter_draw_get_btn(CONTEXT_SETTINGS_RECTRIGGER, 0, pm_y,
 511                                          SYSFONT_HEIGHT, NB_SCREENS);
 512         FOR_NB_SCREENS(i)
 513             screens[i].update();
 514         i = gui_synclist_get_sel_pos(&lists);
 515         switch (action)
 516         {
 517             case ACTION_STD_CANCEL:
 518                 gui_syncsplash(HZ/2, str(LANG_CANCEL));
 519                 global_settings.rec_start_thres_db = old_start_thres_db;
 520                 global_settings.rec_start_thres_linear = old_start_thres_linear;
 521                 global_settings.rec_start_duration = old_start_duration;
 522                 global_settings.rec_prerecord_time = old_prerecord_time;
 523                 global_settings.rec_stop_thres_db = old_stop_thres_db;
 524                 global_settings.rec_stop_thres_linear = old_stop_thres_linear;
 525                 global_settings.rec_stop_postrec = old_stop_postrec;
 526                 global_settings.rec_stop_gap = old_stop_gap;
 527                 global_settings.rec_trigger_mode = old_trigger_mode;
 528                 global_settings.rec_trigger_type = old_trigger_type;
 529                 peak_meter_trigger(global_settings.rec_trigger_mode!=TRIG_OFF);
 530                 settings_apply_trigger();
 531                 done = true;
 532                 break;
 533             case ACTION_STD_OK:
 534                 done = true;
 535                 break;
 536             case ACTION_SETTINGS_DEC:
 537             case ACTION_SETTINGS_DECREPEAT:
 538                 option_select_next_val(settings[i/2], true, false);
 539                 trigger_speak_item(settings[i/2], false);
 540                 changed = true;
 541                 break;
 542             case ACTION_SETTINGS_INC:
 543             case ACTION_SETTINGS_INCREPEAT:
 544                 option_select_next_val(settings[i/2], false, false);
 545                 trigger_speak_item(settings[i/2], false);
 546                 changed = true;
 547                 break;
 548             case ACTION_STD_PREV:
 549             case ACTION_STD_PREVREPEAT:
 550                 i -= 2;
 551                 if (i<0)
 552                     i = (TRIG_OPTION_COUNT*2) - 2;
 553                 gui_synclist_select_item(&lists, i);
 554                 i = gui_synclist_get_sel_pos(&lists);
 555                 trigger_speak_item(settings[i/2], true);
 556                 changed = true;
 557                 break;
 558             case ACTION_STD_NEXT:
 559             case ACTION_STD_NEXTREPEAT:
 560                 gui_synclist_select_item(&lists, (i+2) % (TRIG_OPTION_COUNT*2));
 561                 i = gui_synclist_get_sel_pos(&lists);
 562                 trigger_speak_item(settings[i/2], true);
 563                 changed = true;
 564                 break;
 565         }
 566     }
 567     peak_meter_trigger(false);
 568     settings_save();
 569     return 0;
 570 }
 571 MENUITEM_FUNCTION(rectrigger_item, 0, ID2P(LANG_RECORD_TRIGGER),
 572                   rectrigger, NULL, NULL, Icon_Menu_setting);
 573
 574
 575
 576 /* from main_menu.c */
 577 struct browse_folder_info {
 578     const char* dir;
 579     int show_options;
 580 };
 581 static struct browse_folder_info rec_config_browse = {RECPRESETS_DIR, SHOW_CFG};
 582 int browse_folder(void *param);
 583 MENUITEM_FUNCTION(browse_recconfigs, MENU_FUNC_USEPARAM, ID2P(LANG_CUSTOM_CFG),
 584                   browse_folder, (void*)&rec_config_browse, NULL, Icon_Config);
 585 static int write_settings_file(void)
 586 {
 587     return settings_save_config(SETTINGS_SAVE_RECPRESETS);
 588 }
 589 MENUITEM_FUNCTION(save_recpresets_item, 0, ID2P(LANG_SAVE_SETTINGS),
 590                   write_settings_file, NULL, NULL, Icon_Config);
 591
 592 MAKE_MENU(recording_settings_menu, ID2P(LANG_RECORDING_SETTINGS),
 593             NULL, Icon_Recording,
 594 #if CONFIG_CODEC == MAS3587F
 595             &rec_quality,
 596 #endif
 597 #if CONFIG_CODEC == SWCODEC
 598             &recformat, &enc_global_config_menu_item,
 599 #endif
 600             &recfrequency, &recsource, /* recsource not shown if no_source */
 601             &recchannels,
 602 #if CONFIG_CODEC == MAS3587F
 603             &rec_editable,
 604 #endif
 605             &filesplitoptionsmenu,
 606             &rec_prerecord_time,
 607             &clear_rec_directory_item,
 608 #ifdef HAVE_BACKLIGHT
 609             &cliplight,
 610 #endif
 611             &rectrigger_item,
 612 #ifdef HAVE_AGC
 613             &agc_preset, &agc_cliptime,
 614 #endif
 615             &browse_recconfigs, &save_recpresets_item
 616 );
 617
 618 bool recording_menu(bool no_source)
 619 {
 620     bool retval;
 621     no_source_in_menu = no_source;
 622     retval = do_menu(&recording_settings_menu, NULL, NULL, false) == MENU_ATTACHED_USB;
 623     no_source_in_menu = false; /* always fall back to the default */
 624     return retval;
 625 };
 626
 627 MENUITEM_FUNCTION(recording_settings, MENU_FUNC_USEPARAM, ID2P(LANG_RECORDING_SETTINGS),
 628                           (int (*)(void*))recording_menu, 0, NULL, Icon_Recording);