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