remove the 2nd last evil use of ata_disk_is_active() in apps/
[Rockbox.git] / apps / enc_config.c
blobe1956ed9602706b338e7318af24a885bcfdb0618
1 /***************************************************************************
2 * __________ __ ___.
3 * Open \______ \ ____ ____ | | _\_ |__ _______ ___
4 * Source | _// _ \_/ ___\| |/ /| __ \ / _ \ \/ /
5 * Jukebox | | ( <_> ) \___| < | \_\ ( <_> > < <
6 * Firmware |____|_ /\____/ \___ >__|_ \|___ /\____/__/\_ \
7 * \/ \/ \/ \/ \/
8 * $Id$
10 * Copyright (C) 2006 Michael Sevakis
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.
15 * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY
16 * KIND, either express or implied.
18 ****************************************************************************/
19 #include <stdio.h>
20 #include <sprintf.h>
21 #include <string.h>
22 #include <stdlib.h>
23 #include "config.h"
24 #include "action.h"
25 #include "lang.h"
26 #include "misc.h"
27 #include "talk.h"
28 #include "general.h"
29 #include "codecs.h"
30 #include "menu.h"
31 #include "statusbar.h"
32 #include "settings.h"
33 #include "audio.h"
34 #include "pcm_record.h"
35 #include "enc_config.h"
36 #include "splash.h"
39 #define CALL_FN_(fn, ...) \
40 if (fn) fn(__VA_ARGS__)
42 static int enc_menuitem_callback(int action,
43 const struct menu_item_ex *this_item);
44 static int enc_menuitem_enteritem(int action,
45 const struct menu_item_ex *this_item);
46 static void enc_rec_settings_changed(struct encoder_config *cfg);
47 /* this is used by all encoder menu items,
48 MUST be initialised before the call to do_menu() */
49 static struct menucallback_data {
50 struct encoder_config *cfg;
51 bool global;
52 } menu_callback_data;
54 /** Function definitions for each codec - add these to enc_data
55 list following the definitions **/
57 /** aiff_enc.codec **/
59 /** mp3_enc.codec **/
60 /* mp3_enc: return encoder capabilities */
61 static void mp3_enc_get_caps(const struct encoder_config *cfg,
62 struct encoder_caps *caps,
63 bool for_config)
65 int i;
66 unsigned long bitr;
68 if (!for_config)
70 /* Overall encoder capabilities */
71 caps->samplerate_caps = MPEG1_SAMPR_CAPS | MPEG2_SAMPR_CAPS;
72 caps->channel_caps = CHN_CAP_ALL;
73 return;
76 /* Restrict caps based on config */
77 i = round_value_to_list32(cfg->mp3_enc.bitrate, mp3_enc_bitr,
78 MP3_ENC_NUM_BITR, false);
79 bitr = mp3_enc_bitr[i];
81 /* sample rate caps */
83 /* check if MPEG1 sample rates are available */
84 if ((bitr >= 32 && bitr <= 128) || bitr >= 160)
85 caps->samplerate_caps |= MPEG1_SAMPR_CAPS;
87 /* check if MPEG2 sample rates and mono are available */
88 if (bitr <= 160)
90 caps->samplerate_caps |= MPEG2_SAMPR_CAPS;
91 caps->channel_caps |= CHN_CAP_MONO;
94 /* check if stereo is available */
95 if (bitr >= 32)
96 caps->channel_caps |= CHN_CAP_STEREO;
97 } /* mp3_enc_get_caps */
99 /* mp3_enc: return the default configuration */
100 static void mp3_enc_default_config(struct encoder_config *cfg)
102 cfg->mp3_enc.bitrate = 128; /* default that works for all types */
103 } /* mp3_enc_default_config */
105 static void mp3_enc_convert_config(struct encoder_config *cfg,
106 bool global)
108 if (global)
110 global_settings.mp3_enc_config.bitrate =
111 round_value_to_list32(cfg->mp3_enc.bitrate, mp3_enc_bitr,
112 MP3_ENC_NUM_BITR, false);
114 else
116 if ((unsigned)global_settings.mp3_enc_config.bitrate > MP3_ENC_NUM_BITR)
117 global_settings.mp3_enc_config.bitrate = MP3_ENC_BITRATE_CFG_DEFAULT;
118 cfg->mp3_enc.bitrate = mp3_enc_bitr[global_settings.mp3_enc_config.bitrate];
120 } /* mp3_enc_convert_config */
122 /* mp3_enc: show the bitrate setting options */
123 static bool mp3_enc_bitrate(struct menucallback_data *data)
125 struct encoder_config *cfg = data->cfg;
126 static const struct opt_items items[] =
128 /* Available in MPEG Version: */
129 #ifdef HAVE_MPEG2_SAMPR
130 #if 0
131 /* this sounds awful no matter what */
132 { "8 kBit/s", TALK_ID(8, UNIT_KBIT) }, /* 2 */
133 #endif
134 /* mono only */
135 { "16 kBit/s", TALK_ID(16, UNIT_KBIT) }, /* 2 */
136 { "24 kBit/s", TALK_ID(24, UNIT_KBIT) }, /* 2 */
137 #endif /* HAVE_MPEG2_SAMPR */
138 /* stereo/mono */
139 { "32 kBit/s", TALK_ID(32, UNIT_KBIT) }, /* 1,2 */
140 { "40 kBit/s", TALK_ID(40, UNIT_KBIT) }, /* 1,2 */
141 { "48 kBit/s", TALK_ID(48, UNIT_KBIT) }, /* 1,2 */
142 { "56 kBit/s", TALK_ID(56, UNIT_KBIT) }, /* 1,2 */
143 { "64 kBit/s", TALK_ID(64, UNIT_KBIT) }, /* 1,2 */
144 { "80 kBit/s", TALK_ID(80, UNIT_KBIT) }, /* 1,2 */
145 { "96 kBit/s", TALK_ID(96, UNIT_KBIT) }, /* 1,2 */
146 { "112 kBit/s", TALK_ID(112, UNIT_KBIT) }, /* 1,2 */
147 { "128 kBit/s", TALK_ID(128, UNIT_KBIT) }, /* 1,2 */
148 /* Leave out 144 when there is both MPEG 1 and 2 */
149 #if defined(HAVE_MPEG2_SAMPR) && !defined (HAVE_MPEG1_SAMPR)
150 /* oddball MPEG2-only rate stuck in the middle */
151 { "144 kBit/s", TALK_ID(144, UNIT_KBIT) }, /* 2 */
152 #endif
153 { "160 kBit/s", TALK_ID(160, UNIT_KBIT) }, /* 1,2 */
154 #ifdef HAVE_MPEG1_SAMPR
155 /* stereo only */
156 { "192 kBit/s", TALK_ID(192, UNIT_KBIT) }, /* 1 */
157 { "224 kBit/s", TALK_ID(224, UNIT_KBIT) }, /* 1 */
158 { "256 kBit/s", TALK_ID(256, UNIT_KBIT) }, /* 1 */
159 { "320 kBit/s", TALK_ID(320, UNIT_KBIT) }, /* 1 */
160 #endif
163 unsigned long rate_list[ARRAYLEN(items)];
165 /* This is rather constant based upon the build but better than
166 storing and maintaining yet another list of numbers */
167 int n_rates = make_list_from_caps32(
168 MPEG1_BITR_CAPS | MPEG2_BITR_CAPS, mp3_enc_bitr,
170 #ifdef HAVE_MPEG1_SAMPR
171 | MPEG1_BITR_CAPS
172 #endif
173 #ifdef HAVE_MPEG2_SAMPR
174 #ifdef HAVE_MPEG1_SAMPR
175 | (MPEG2_BITR_CAPS & ~(MP3_BITR_CAP_144 | MP3_BITR_CAP_8))
176 #else
177 | (MPEG2_BITR_CAPS & ~(MP3_BITR_CAP_8))
178 #endif
179 #endif /* HAVE_MPEG2_SAMPR */
180 , rate_list);
182 int index = round_value_to_list32(cfg->mp3_enc.bitrate, rate_list,
183 n_rates, false);
184 bool res = set_option(str(LANG_BITRATE), &index, INT,
185 items, n_rates, NULL);
186 index = round_value_to_list32(rate_list[index], mp3_enc_bitr,
187 MP3_ENC_NUM_BITR, false);
188 cfg->mp3_enc.bitrate = mp3_enc_bitr[index];
190 return res;
191 } /* mp3_enc_bitrate */
193 /* mp3_enc configuration menu */
194 MENUITEM_FUNCTION(mp3_bitrate, MENU_FUNC_USEPARAM, ID2P(LANG_BITRATE),
195 mp3_enc_bitrate,
196 &menu_callback_data, enc_menuitem_callback, Icon_NOICON);
197 MAKE_MENU( mp3_enc_menu, ID2P(LANG_ENCODER_SETTINGS),
198 enc_menuitem_enteritem, Icon_NOICON,
199 &mp3_bitrate);
202 /** wav_enc.codec **/
203 /* wav_enc: show the configuration menu */
204 #if 0
205 MAKE_MENU( wav_enc_menu, ID2P(LANG_ENCODER_SETTINGS),
206 enc_menuitem_enteritem, Icon_NOICON,
208 #endif
210 /** wavpack_enc.codec **/
211 /* wavpack_enc: show the configuration menu */
212 #if 0
213 MAKE_MENU( wavpack_enc_menu, ID2P(LANG_ENCODER_SETTINGS),
214 enc_menuitem_enteritem, Icon_NOICON,
216 #endif
218 /** config function pointers and/or data for each codec **/
219 static const struct encoder_data
221 void (*get_caps)(const struct encoder_config *cfg,
222 struct encoder_caps *caps, bool for_config);
223 void (*default_cfg)(struct encoder_config *cfg);
224 void (*convert_cfg)(struct encoder_config *cfg , bool global);
225 const struct menu_item_ex *menu;
226 } enc_data[REC_NUM_FORMATS] =
228 /* aiff_enc.codec */
229 [REC_FORMAT_AIFF] = {
230 NULL,
231 NULL,
232 NULL,
233 NULL,
235 /* mp3_enc.codec */
236 [REC_FORMAT_MPA_L3] = {
237 mp3_enc_get_caps,
238 mp3_enc_default_config,
239 mp3_enc_convert_config,
240 &mp3_enc_menu,
242 /* wav_enc.codec */
243 [REC_FORMAT_PCM_WAV] = {
244 NULL,
245 NULL,
246 NULL,
247 NULL,
249 /* wavpack_enc.codec */
250 [REC_FORMAT_WAVPACK] = {
251 NULL,
252 NULL,
253 NULL,
254 NULL,
258 static inline bool rec_format_ok(int rec_format)
260 return (unsigned)rec_format < REC_NUM_FORMATS;
262 /* This is called before entering the menu with the encoder settings
263 Its needed to make sure the settings can take effect. */
264 static int enc_menuitem_enteritem(int action,
265 const struct menu_item_ex *this_item)
267 (void)this_item;
268 /* this struct must be init'ed before calling do_menu() so this is safe */
269 struct menucallback_data *data = &menu_callback_data;
270 if (action == ACTION_STD_OK) /* entering the item */
272 if (data->global)
273 global_to_encoder_config(data->cfg);
275 return action;
277 /* this is called when a encoder setting is exited
278 It is used to update the status bar and save the setting */
279 static int enc_menuitem_callback(int action,
280 const struct menu_item_ex *this_item)
282 struct menucallback_data *data =
283 (struct menucallback_data*)this_item->function->param;
285 if (action == ACTION_EXIT_MENUITEM)
287 /* If the setting being configured is global, it must be placed
288 in global_settings before updating the status bar for the
289 change to show upon exiting the item. */
290 if (data->global)
292 enc_rec_settings_changed(data->cfg);
293 encoder_config_to_global(data->cfg);
296 gui_syncstatusbar_draw(&statusbars, true);
298 return action;
301 /* update settings dependent upon encoder settings */
302 static void enc_rec_settings_changed(struct encoder_config *cfg)
304 struct encoder_config enc_config;
305 struct encoder_caps caps;
306 long table[MAX(CHN_NUM_MODES, REC_NUM_FREQ)];
307 int n;
309 if (cfg == NULL)
311 cfg = &enc_config;
312 cfg->rec_format = global_settings.rec_format;
313 global_to_encoder_config(cfg);
316 /* have to sync other settings when encoder settings change */
317 if (!enc_get_caps(cfg, &caps, true))
318 return;
320 /* rec_channels */
321 n = make_list_from_caps32(CHN_CAP_ALL, NULL,
322 caps.channel_caps, table);
324 /* no zero check needed: encoder must support at least one
325 sample rate that recording supports or it shouldn't be in
326 available in the recording options */
327 n = round_value_to_list32(global_settings.rec_channels,
328 table, n, true);
329 global_settings.rec_channels = table[n];
331 /* rec_frequency */
332 n = make_list_from_caps32(REC_SAMPR_CAPS, rec_freq_sampr,
333 caps.samplerate_caps, table);
335 n = round_value_to_list32(
336 rec_freq_sampr[global_settings.rec_frequency],
337 table, n, false);
339 global_settings.rec_frequency = round_value_to_list32(
340 table[n], rec_freq_sampr, REC_NUM_FREQ, false);
341 } /* enc_rec_settings_changed */
343 /** public stuff **/
344 void global_to_encoder_config(struct encoder_config *cfg)
346 const struct encoder_data *data = &enc_data[cfg->rec_format];
347 CALL_FN_(data->convert_cfg, cfg, false);
348 } /* global_to_encoder_config */
350 void encoder_config_to_global(const struct encoder_config *cfg)
352 const struct encoder_data *data = &enc_data[cfg->rec_format];
353 CALL_FN_(data->convert_cfg, (struct encoder_config *)cfg, true);
354 } /* encoder_config_to_global */
356 bool enc_get_caps(const struct encoder_config *cfg,
357 struct encoder_caps *caps,
358 bool for_config)
360 /* get_caps expects caps to be zeroed first */
361 memset(caps, 0, sizeof (*caps));
363 if (!rec_format_ok(cfg->rec_format))
364 return false;
366 if (enc_data[cfg->rec_format].get_caps)
368 enc_data[cfg->rec_format].get_caps(cfg, caps, for_config);
370 else
372 /* If no function provided...defaults to all */
373 caps->samplerate_caps = SAMPR_CAP_ALL;
374 caps->channel_caps = CHN_CAP_ALL;
377 return true;
378 } /* enc_get_caps */
380 /* Initializes the config struct with default values */
381 bool enc_init_config(struct encoder_config *cfg)
383 if (!rec_format_ok(cfg->rec_format))
384 return false;
385 CALL_FN_(enc_data[cfg->rec_format].default_cfg, cfg);
386 return true;
387 } /* enc_init_config */
389 /** Encoder Menus **/
390 #if 0
391 bool enc_config_menu(struct encoder_config *cfg)
393 if (!rec_format_ok(cfg->rec_format))
394 return false;
395 if (enc_data[cfg->rec_format].menu)
397 menu_callback_data.cfg = &cfg;
398 menu_callback_data.global = false;
399 return do_menu(enc_data[cfg->rec_format].menu, NULL, NULL, false)
400 == MENU_ATTACHED_USB;
402 else
404 gui_syncsplash(HZ, str(LANG_NO_SETTINGS));
405 return false;
407 } /* enc_config_menu */
408 #endif
410 /** Global Settings **/
412 /* Reset all codecs to defaults */
413 void enc_global_settings_reset(void)
415 struct encoder_config cfg;
416 cfg.rec_format = 0;
420 global_to_encoder_config(&cfg);
421 enc_init_config(&cfg);
422 encoder_config_to_global(&cfg);
423 if (cfg.rec_format == global_settings.rec_format)
424 enc_rec_settings_changed(&cfg);
426 while (++cfg.rec_format < REC_NUM_FORMATS);
427 } /* enc_global_settings_reset */
429 /* Apply new settings */
430 void enc_global_settings_apply(void)
432 struct encoder_config cfg;
433 if (!rec_format_ok(global_settings.rec_format))
434 global_settings.rec_format = REC_FORMAT_DEFAULT;
436 cfg.rec_format = global_settings.rec_format;
437 global_to_encoder_config(&cfg);
438 enc_rec_settings_changed(&cfg);
439 encoder_config_to_global(&cfg);
440 } /* enc_global_settings_apply */
442 /* Show an encoder's config menu based on the global_settings.
443 Modified settings are placed in global_settings.enc_config. */
444 bool enc_global_config_menu(void)
446 struct encoder_config cfg;
448 if (!rec_format_ok(global_settings.rec_format))
449 global_settings.rec_format = REC_FORMAT_DEFAULT;
451 cfg.rec_format = global_settings.rec_format;
453 if (enc_data[cfg.rec_format].menu)
455 menu_callback_data.cfg = &cfg;
456 menu_callback_data.global = true;
457 return do_menu(enc_data[cfg.rec_format].menu, NULL, NULL, false)
458 == MENU_ATTACHED_USB;
460 else
462 gui_syncsplash(HZ, str(LANG_NO_SETTINGS));
463 return false;
465 } /* enc_global_config_menu */