| /*************************************************************************** |
| * __________ __ ___. |
| * Open \______ \ ____ ____ | | _\_ |__ _______ ___ |
| * Source | _// _ \_/ ___\| |/ /| __ \ / _ \ \/ / |
| * Jukebox | | ( <_> ) \___| < | \_\ ( <_> > < < |
| * Firmware |____|_ /\____/ \___ >__|_ \|___ /\____/__/\_ \ |
| * \/ \/ \/ \/ \/ |
| * $Id$ |
| * |
| * Copyright (C) 2002 by Linus Nielsen Feltzing |
| * |
| * This program is free software; you can redistribute it and/or |
| * modify it under the terms of the GNU General Public License |
| * as published by the Free Software Foundation; either version 2 |
| * of the License, or (at your option) any later version. |
| * |
| * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY |
| * KIND, either express or implied. |
| * |
| ****************************************************************************/ |
| |
| #include "config.h" |
| |
| #include <stdio.h> |
| #include <stdbool.h> |
| #include <stdlib.h> |
| |
| #include "system.h" |
| #include "power.h" |
| #include "powermgmt.h" |
| #include "lcd.h" |
| #include "led.h" |
| #include "mpeg.h" |
| #include "audio.h" |
| #if CONFIG_CODEC == SWCODEC |
| #include "thread.h" |
| #include "playback.h" |
| #include "enc_config.h" |
| #if defined(HAVE_SPDIF_IN) || defined(HAVE_SPDIF_OUT) |
| #include "spdif.h" |
| #endif |
| #endif /* CONFIG_CODEC == SWCODEC */ |
| #include "recording.h" |
| #include "mp3_playback.h" |
| #include "mas.h" |
| #include "button.h" |
| #include "kernel.h" |
| #include "settings.h" |
| #include "lang.h" |
| #include "font.h" |
| #include "icons.h" |
| #include "icon.h" |
| #include "screens.h" |
| #include "peakmeter.h" |
| #include "statusbar.h" |
| #include "menu.h" |
| #include "sound_menu.h" |
| #include "timefuncs.h" |
| #include "debug.h" |
| #include "misc.h" |
| #include "tree.h" |
| #include "string.h" |
| #include "dir.h" |
| #include "errno.h" |
| #include "talk.h" |
| #include "sound.h" |
| #include "ata.h" |
| #include "splash.h" |
| #include "screen_access.h" |
| #include "action.h" |
| #include "radio.h" |
| #include "sound_menu.h" |
| #include "viewport.h" |
| |
| #ifdef HAVE_RECORDING |
| /* This array holds the record timer interval lengths, in seconds */ |
| static const unsigned long rec_timer_seconds[] = |
| { |
| 0, /* 0 means OFF */ |
| 5*60, /* 00:05 */ |
| 10*60, /* 00:10 */ |
| 15*60, /* 00:15 */ |
| 30*60, /* 00:30 */ |
| 60*60, /* 01:00 */ |
| 74*60, /* 74:00 */ |
| 80*60, /* 80:00 */ |
| 2*60*60, /* 02:00 */ |
| 4*60*60, /* 04:00 */ |
| 6*60*60, /* 06:00 */ |
| 8*60*60, /* 08:00 */ |
| 10L*60*60, /* 10:00 */ |
| 12L*60*60, /* 12:00 */ |
| 18L*60*60, /* 18:00 */ |
| 24L*60*60 /* 24:00 */ |
| }; |
| |
| static unsigned int rec_timesplit_seconds(void) |
| { |
| return rec_timer_seconds[global_settings.rec_timesplit]; |
| } |
| |
| /* This array holds the record size interval lengths, in bytes */ |
| static const unsigned long rec_size_bytes[] = |
| { |
| 0, /* 0 means OFF */ |
| 5*1024*1024, /* 5MB */ |
| 10*1024*1024, /* 10MB */ |
| 15*1024*1024, /* 15MB */ |
| 32*1024*1024, /* 32MB */ |
| 64*1024*1024, /* 64MB */ |
| 75*1024*1024, /* 75MB */ |
| 100*1024*1024, /* 100MB */ |
| 128*1024*1024, /* 128MB */ |
| 256*1024*1024, /* 256MB */ |
| 512*1024*1024, /* 512MB */ |
| 650*1024*1024, /* 650MB */ |
| 700*1024*1024, /* 700MB */ |
| 1024*1024*1024, /* 1GB */ |
| 1536*1024*1024, /* 1.5GB */ |
| 1792*1024*1024, /* 1.75GB */ |
| }; |
| |
| static unsigned long rec_sizesplit_bytes(void) |
| { |
| return rec_size_bytes[global_settings.rec_sizesplit]; |
| } |
| |
| void settings_apply_trigger(void) |
| { |
| int start_thres, stop_thres; |
| if (global_settings.peak_meter_dbfs) |
| { |
| start_thres = global_settings.rec_start_thres_db - 1; |
| stop_thres = global_settings.rec_stop_thres_db - 1; |
| } |
| else |
| { |
| start_thres = global_settings.rec_start_thres_linear; |
| stop_thres = global_settings.rec_stop_thres_linear; |
| } |
| |
| peak_meter_define_trigger( |
| start_thres, |
| global_settings.rec_start_duration*HZ, |
| MIN(global_settings.rec_start_duration*HZ / 2, 2*HZ), |
| stop_thres, |
| global_settings.rec_stop_postrec*HZ, |
| global_settings.rec_stop_gap*HZ |
| ); |
| } |
| /* recording screen status flags */ |
| enum rec_status_flags |
| { |
| RCSTAT_IN_RECSCREEN = 0x00000001, |
| RCSTAT_BEEN_IN_USB_MODE = 0x00000002, |
| RCSTAT_CREATED_DIRECTORY = 0x00000004, |
| RCSTAT_HAVE_RECORDED = 0x00000008, |
| }; |
| |
| static int rec_status = 0; |
| |
| bool in_recording_screen(void) |
| { |
| return (rec_status & RCSTAT_IN_RECSCREEN) != 0; |
| } |
| |
| #define PM_HEIGHT ((LCD_HEIGHT >= 72) ? 2 : 1) |
| |
| #if CONFIG_KEYPAD == RECORDER_PAD |
| static bool f2_rec_screen(void); |
| static bool f3_rec_screen(void); |
| #endif |
| |
| #define MAX_FILE_SIZE 0x7F800000 /* 2 GB - 4 MB */ |
| |
| #ifndef HAVE_REMOTE_LCD |
| static const int screen_update = NB_SCREENS; |
| #else |
| static int screen_update = NB_SCREENS; |
| static bool remote_display_on = true; |
| #endif |
| |
| /** File name creation **/ |
| #if CONFIG_RTC == 0 |
| /* current file number to assist in creating unique numbered filenames |
| without actually having to create the file on disk */ |
| static int file_number = -1; |
| #endif /* CONFIG_RTC */ |
| |
| #if CONFIG_CODEC == SWCODEC |
| |
| #define REC_FILE_ENDING(rec_format) \ |
| (audio_formats[rec_format_afmt[rec_format]].ext_list) |
| |
| #else /* CONFIG_CODEC != SWCODEC */ |
| |
| /* default record file extension for HWCODEC */ |
| #define REC_FILE_ENDING(rec_format) \ |
| (audio_formats[AFMT_MPA_L3].ext_list) |
| |
| #endif /* CONFIG_CODEC == SWCODEC */ |
| |
| /* path for current file */ |
| static char path_buffer[MAX_PATH]; |
| |
| /** Automatic Gain Control (AGC) **/ |
| #ifdef HAVE_AGC |
| /* Timing counters: |
| * peak_time is incremented every 0.2s, every 2nd run of record screen loop. |
| * hist_time is incremented every 0.5s, display update. |
| * peak_time is the counter of the peak hold read and agc process, |
| * overflow every 13 years 8-) |
| */ |
| static long peak_time = 0; |
| static long hist_time = 0; |
| |
| static short peak_valid_mem[4]; |
| #define BAL_MEM_SIZE 24 |
| static short balance_mem[BAL_MEM_SIZE]; |
| |
| /* Automatic Gain Control */ |
| #define AGC_MODE_SIZE 5 |
| #define AGC_SAFETY_MODE 0 |
| |
| static const char* agc_preset_str[] = |
| { "Off", "S", "L", "D", "M", "V" }; |
| /* "Off", |
| "Safety (clip)", |
| "Live (slow)", |
| "DJ-Set (slow)", |
| "Medium", |
| "Voice (fast)" */ |
| #define AGC_CLIP 32766 |
| #define AGC_PEAK 29883 /* fast gain reduction threshold -0.8dB */ |
| #define AGC_HIGH 27254 /* accelerated gain reduction threshold -1.6dB */ |
| #define AGC_IMG 823 /* threshold for balance control -32dB */ |
| /* autogain high level thresholds (-3dB, -7dB, -4dB, -5dB, -5dB) */ |
| static const short agc_th_hi[AGC_MODE_SIZE] = |
| { 23197, 14637, 21156, 18428, 18426 }; |
| /* autogain low level thresholds (-14dB, -11dB, -6dB, -7dB, -8dB) */ |
| static const short agc_th_lo[AGC_MODE_SIZE] = |
| { 6538, 9235, 16422, 14636, 13045 }; |
| /* autogain threshold times [1/5s] or [200ms] */ |
| static const short agc_tdrop[AGC_MODE_SIZE] = |
| { 900, 225, 150, 60, 8 }; |
| static const short agc_trise[AGC_MODE_SIZE] = |
| { 9000, 750, 400, 150, 20 }; |
| static const short agc_tbal[AGC_MODE_SIZE] = |
| { 4500, 500, 300, 100, 15 }; |
| /* AGC operation */ |
| static bool agc_enable = true; |
| static short agc_preset; |
| /* AGC levels */ |
| static int agc_left = 0; |
| static int agc_right = 0; |
| /* AGC time since high target volume was exceeded */ |
| static short agc_droptime = 0; |
| /* AGC time since volume fallen below low target */ |
| static short agc_risetime = 0; |
| /* AGC balance time exceeding +/- 0.7dB */ |
| static short agc_baltime = 0; |
| /* AGC maximum gain */ |
| static short agc_maxgain; |
| #endif /* HAVE_AGC */ |
| |
| static void set_gain(void) |
| { |
| if(global_settings.rec_source == AUDIO_SRC_MIC) |
| { |
| audio_set_recording_gain(global_settings.rec_mic_gain, |
| 0, AUDIO_GAIN_MIC); |
| } |
| else |
| { |
| /* AUDIO_SRC_LINEIN, AUDIO_SRC_FMRADIO, AUDIO_SRC_SPDIF */ |
| audio_set_recording_gain(global_settings.rec_left_gain, |
| global_settings.rec_right_gain, |
| AUDIO_GAIN_LINEIN); |
| } |
| /* reset the clipping indicators */ |
| peak_meter_set_clip_hold(global_settings.peak_meter_clip_hold); |
| } |
| |
| #ifdef HAVE_AGC |
| /* Read peak meter values & calculate balance. |
| * Returns validity of peak values. |
| * Used for automatic gain control and history diagram. |
| */ |
| static bool read_peak_levels(int *peak_l, int *peak_r, int *balance) |
| { |
| peak_meter_get_peakhold(peak_l, peak_r); |
| peak_valid_mem[peak_time % 3] = *peak_l; |
| if (((peak_valid_mem[0] == peak_valid_mem[1]) && |
| (peak_valid_mem[1] == peak_valid_mem[2])) && |
| ((*peak_l < 32767) |
| #ifndef SIMULATOR |
| || ata_disk_is_active() |
| #endif |
| )) |
| return false; |
| |
| if (*peak_r > *peak_l) |
| balance_mem[peak_time % BAL_MEM_SIZE] = (*peak_l ? |
| MIN((10000 * *peak_r) / *peak_l - 10000, 15118) : 15118); |
| else |
| balance_mem[peak_time % BAL_MEM_SIZE] = (*peak_r ? |
| MAX(10000 - (10000 * *peak_l) / *peak_r, -15118) : -15118); |
| *balance = 0; |
| int i; |
| for (i = 0; i < BAL_MEM_SIZE; i++) |
| *balance += balance_mem[i]; |
| *balance = *balance / BAL_MEM_SIZE; |
| |
| return true; |
| } |
| |
| /* AGC helper function to check if maximum gain is reached */ |
| static bool agc_gain_is_max(bool left, bool right) |
| { |
| /* range -128...+108 [0.5dB] */ |
| short gain_current_l; |
| short gain_current_r; |
| |
| if (agc_preset == 0) |
| return false; |
| |
| switch (global_settings.rec_source) |
| { |
| HAVE_LINE_REC_(case AUDIO_SRC_LINEIN:) |
| HAVE_FMRADIO_REC_(case AUDIO_SRC_FMRADIO:) |
| gain_current_l = global_settings.rec_left_gain; |
| gain_current_r = global_settings.rec_right_gain; |
| break; |
| case AUDIO_SRC_MIC: |
| default: |
| gain_current_l = global_settings.rec_mic_gain; |
| gain_current_r = global_settings.rec_mic_gain; |
| } |
| |
| return ((left && (gain_current_l >= agc_maxgain)) || |
| (right && (gain_current_r >= agc_maxgain))); |
| } |
| |
| static void change_recording_gain(bool increment, bool left, bool right) |
| { |
| int factor = (increment ? 1 : -1); |
| |
| switch (global_settings.rec_source) |
| { |
| HAVE_LINE_REC_(case AUDIO_SRC_LINEIN:) |
| HAVE_FMRADIO_REC_(case AUDIO_SRC_FMRADIO:) |
| if (left) global_settings.rec_left_gain += factor; |
| if (right) global_settings.rec_right_gain += factor; |
| break; |
| case AUDIO_SRC_MIC: |
| global_settings.rec_mic_gain += factor; |
| } |
| } |
| |
| /* |
| * Handle automatic gain control (AGC). |
| * Change recording gain if peak_x levels are above or below |
| * target volume for specified timeouts. |
| */ |
| static void auto_gain_control(int *peak_l, int *peak_r, int *balance) |
| { |
| int agc_mono; |
| short agc_mode; |
| bool increment; |
| |
| if (*peak_l > agc_left) |
| agc_left = *peak_l; |
| else |
| agc_left -= (agc_left - *peak_l + 3) >> 2; |
| if (*peak_r > agc_right) |
| agc_right = *peak_r; |
| else |
| agc_right -= (agc_right - *peak_r + 3) >> 2; |
| agc_mono = (agc_left + agc_right) / 2; |
| |
| agc_mode = abs(agc_preset) - 1; |
| if (agc_mode < 0) { |
| agc_enable = false; |
| return; |
| } |
| |
| if (agc_mode != AGC_SAFETY_MODE) { |
| /* Automatic balance control - only if not in safety mode */ |
| if ((agc_left > AGC_IMG) && (agc_right > AGC_IMG)) |
| { |
| if (*balance < -556) |
| { |
| if (*balance > -900) |
| agc_baltime -= !(peak_time % 4); /* 0.47 - 0.75dB */ |
| else if (*balance > -4125) |
| agc_baltime--; /* 0.75 - 3.00dB */ |
| else if (*balance > -7579) |
| agc_baltime -= 2; /* 3.00 - 4.90dB */ |
| else |
| agc_baltime -= !(peak_time % 8); /* 4.90 - inf dB */ |
| if (agc_baltime > 0) |
| agc_baltime -= (peak_time % 2); |
| } |
| else if (*balance > 556) |
| { |
| if (*balance < 900) |
| agc_baltime += !(peak_time % 4); |
| else if (*balance < 4125) |
| agc_baltime++; |
| else if (*balance < 7579) |
| agc_baltime += 2; |
| else |
| agc_baltime += !(peak_time % 8); |
| if (agc_baltime < 0) |
| agc_baltime += (peak_time % 2); |
| } |
| |
| if ((*balance * agc_baltime) < 0) |
| { |
| if (*balance < 0) |
| agc_baltime -= peak_time % 2; |
| else |
| agc_baltime += peak_time % 2; |
| } |
| |
| increment = ((agc_risetime / 2) > agc_droptime); |
| |
| if (agc_baltime < -agc_tbal[agc_mode]) |
| { |
| if (!increment || !agc_gain_is_max(!increment, increment)) { |
| change_recording_gain(increment, !increment, increment); |
| set_gain(); |
| } |
| agc_baltime = 0; |
| } |
| else if (agc_baltime > +agc_tbal[agc_mode]) |
| { |
| if (!increment || !agc_gain_is_max(increment, !increment)) { |
| change_recording_gain(increment, increment, !increment); |
| set_gain(); |
| } |
| agc_baltime = 0; |
| } |
| } |
| else if (!(hist_time % 4)) |
| { |
| if (agc_baltime < 0) |
| agc_baltime++; |
| else |
| agc_baltime--; |
| } |
| } |
| |
| /* Automatic gain control */ |
| if ((agc_left > agc_th_hi[agc_mode]) || (agc_right > agc_th_hi[agc_mode])) |
| { |
| if ((agc_left > AGC_CLIP) || (agc_right > AGC_CLIP)) |
| agc_droptime += agc_tdrop[agc_mode] / |
| (global_settings.rec_agc_cliptime + 1); |
| if (agc_left > AGC_HIGH) { |
| agc_droptime++; |
| agc_risetime=0; |
| if (agc_left > AGC_PEAK) |
| agc_droptime += 2; |
| } |
| if (agc_right > AGC_HIGH) { |
| agc_droptime++; |
| agc_risetime=0; |
| if (agc_right > AGC_PEAK) |
| agc_droptime += 2; |
| } |
| if (agc_mono > agc_th_hi[agc_mode]) |
| agc_droptime++; |
| else |
| agc_droptime += !(peak_time % 2); |
| |
| if (agc_droptime >= agc_tdrop[agc_mode]) |
| { |
| change_recording_gain(false, true, true); |
| agc_droptime = 0; |
| agc_risetime = 0; |
| set_gain(); |
| } |
| agc_risetime = MAX(agc_risetime - 1, 0); |
| } |
| else if (agc_mono < agc_th_lo[agc_mode]) |
| { |
| if (agc_mono < (agc_th_lo[agc_mode] / 8)) |
| agc_risetime += !(peak_time % 5); |
| else if (agc_mono < (agc_th_lo[agc_mode] / 2)) |
| agc_risetime += 2; |
| else |
| agc_risetime++; |
| |
| if (agc_risetime >= agc_trise[agc_mode]) { |
| if ((agc_mode != AGC_SAFETY_MODE) && |
| (!agc_gain_is_max(true, true))) { |
| change_recording_gain(true, true, true); |
| set_gain(); |
| } |
| agc_risetime = 0; |
| agc_droptime = 0; |
| } |
| agc_droptime = MAX(agc_droptime - 1, 0); |
| } |
| else if (!(peak_time % 6)) /* on target level every 1.2 sec */ |
| { |
| agc_risetime = MAX(agc_risetime - 1, 0); |
| agc_droptime = MAX(agc_droptime - 1, 0); |
| } |
| } |
| #endif /* HAVE_AGC */ |
| |
| static const char* const fmtstr[] = |
| { |
| "%c%d %s", /* no decimals */ |
| "%c%d.%d %s ", /* 1 decimal */ |
| "%c%d.%02d %s " /* 2 decimals */ |
| }; |
| |
| static char *fmt_gain(int snd, int val, char *str, int len) |
| { |
| int i, d, numdec; |
| const char *unit; |
| char sign = ' '; |
| |
| val = sound_val2phys(snd, val); |
| if(val < 0) |
| { |
| sign = '-'; |
| val = -val; |
| } |
| numdec = sound_numdecimals(snd); |
| unit = sound_unit(snd); |
| |
| if(numdec) |
| { |
| i = val / (10*numdec); |
| d = val % (10*numdec); |
| snprintf(str, len, fmtstr[numdec], sign, i, d, unit); |
| } |
| else |
| snprintf(str, len, fmtstr[numdec], sign, val, unit); |
| |
| return str; |
| } |
| |
| static int cursor; |
| |
| static void adjust_cursor(void) |
| { |
| int max_cursor; |
| |
| if(cursor < 0) |
| cursor = 0; |
| |
| #ifdef HAVE_AGC |
| switch(global_settings.rec_source) |
| { |
| case REC_SRC_MIC: |
| if(cursor == 2) |
| cursor = 4; |
| else if(cursor == 3) |
| cursor = 1; |
| HAVE_LINE_REC_(case AUDIO_SRC_LINEIN:) |
| HAVE_FMRADIO_REC_(case AUDIO_SRC_FMRADIO:) |
| max_cursor = 5; |
| break; |
| default: |
| max_cursor = 0; |
| break; |
| } |
| #else /* !HAVE_AGC */ |
| switch(global_settings.rec_source) |
| { |
| case AUDIO_SRC_MIC: |
| max_cursor = 1; |
| break; |
| HAVE_LINE_REC_(case AUDIO_SRC_LINEIN:) |
| HAVE_FMRADIO_REC_(case AUDIO_SRC_FMRADIO:) |
| max_cursor = 3; |
| break; |
| default: |
| max_cursor = 0; |
| break; |
| } |
| #endif /* HAVE_AGC */ |
| |
| if(cursor > max_cursor) |
| cursor = max_cursor; |
| } |
| |
| /* the list below must match enum audio_sources in audio.h */ |
| static const char* const prestr[] = |
| { |
| HAVE_MIC_IN_([AUDIO_SRC_MIC] = "R_MIC_",) |
| HAVE_LINE_REC_([AUDIO_SRC_LINEIN] = "R_LINE_",) |
| HAVE_SPDIF_IN_([AUDIO_SRC_SPDIF] = "R_SPDIF_",) |
| HAVE_FMRADIO_REC_([AUDIO_SRC_FMRADIO] = "R_FM_",) |
| }; |
| |
| char *rec_create_filename(char *buffer) |
| { |
| char ext[16]; |
| const char *pref = "R_"; |
| |
| /* Directory existence and writeablility should have already been |
| * verified - do not pass NULL pointers to pcmrec */ |
| |
| if((unsigned)global_settings.rec_source < AUDIO_NUM_SOURCES) |
| { |
| pref = prestr[global_settings.rec_source]; |
| } |
| |
| strcpy(buffer, global_settings.rec_directory); |
| |
| snprintf(ext, sizeof(ext), ".%s", |
| REC_FILE_ENDING(global_settings.rec_format)); |
| |
| #if CONFIG_RTC == 0 |
| return create_numbered_filename(buffer, buffer, pref, ext, 4, |
| &file_number); |
| #else |
| /* We'll wait at least up to the start of the next second so no duplicate |
| names are created */ |
| return create_datetime_filename(buffer, buffer, pref, ext, true); |
| #endif |
| } |
| |
| #if CONFIG_RTC == 0 |
| /* Hit disk to get a starting filename for the type */ |
| static void rec_init_filename(void) |
| { |
| file_number = -1; |
| rec_create_filename(path_buffer); |
| file_number--; |
| } |
| #endif |
| |
| int rec_create_directory(void) |
| { |
| int rc = 0; |
| const char * const folder = global_settings.rec_directory; |
| |
| if (strcmp(folder, "/") && !dir_exists(folder)) |
| { |
| rc = mkdir(folder); |
| |
| if(rc < 0) |
| { |
| while (action_userabort(HZ) == false) |
| { |
| gui_syncsplash(0, "%s %s", |
| str(LANG_REC_DIR_NOT_WRITABLE), |
| str(LANG_OFF_ABORT)); |
| } |
| } |
| else |
| { |
| rec_status |= RCSTAT_CREATED_DIRECTORY; |
| rc = 1; |
| } |
| } |
| |
| return rc; |
| } |
| |
| void rec_init_recording_options(struct audio_recording_options *options) |
| { |
| options->rec_source = global_settings.rec_source; |
| options->rec_frequency = global_settings.rec_frequency; |
| options->rec_channels = global_settings.rec_channels; |
| options->rec_prerecord_time = global_settings.rec_prerecord_time; |
| #if CONFIG_CODEC == SWCODEC |
| options->rec_source_flags = 0; |
| options->enc_config.rec_format = global_settings.rec_format; |
| global_to_encoder_config(&options->enc_config); |
| #else |
| options->rec_quality = global_settings.rec_quality; |
| options->rec_editable = global_settings.rec_editable; |
| #endif |
| } |
| |
| #if CONFIG_CODEC == SWCODEC && !defined (SIMULATOR) |
| void rec_set_source(int source, unsigned flags) |
| { |
| /* Set audio input source, power up/down devices */ |
| audio_set_input_source(source, flags); |
| |
| /* Set peakmeters for recording or reset to playback */ |
| peak_meter_playback((flags & SRCF_RECORDING) == 0); |
| peak_meter_enabled = true; |
| } |
| #endif /* CONFIG_CODEC == SWCODEC && !defined (SIMULATOR) */ |
| |
| void rec_set_recording_options(struct audio_recording_options *options) |
| { |
| #if CONFIG_CODEC != SWCODEC |
| if (global_settings.rec_prerecord_time) |
| { |
| talk_buffer_steal(); /* will use the mp3 buffer */ |
| } |
| #else /* == SWCODEC */ |
| rec_set_source(options->rec_source, |
| options->rec_source_flags | SRCF_RECORDING); |
| #endif /* CONFIG_CODEC != SWCODEC */ |
| |
| audio_set_recording_options(options); |
| } |
| |
| void rec_command(enum recording_command cmd) |
| { |
| switch(cmd) |
| { |
| case RECORDING_CMD_STOP_SHUTDOWN: |
| pm_activate_clipcount(false); |
| audio_stop_recording(); |
| #if CONFIG_CODEC == SWCODEC |
| audio_close_recording(); |
| #endif |
| sys_poweroff(); |
| break; |
| case RECORDING_CMD_STOP: |
| pm_activate_clipcount(false); |
| audio_stop_recording(); |
| break; |
| case RECORDING_CMD_START: |
| /* steal mp3 buffer, create unique filename and start recording */ |
| pm_reset_clipcount(); |
| pm_activate_clipcount(true); |
| #if CONFIG_CODEC != SWCODEC |
| talk_buffer_steal(); /* we use the mp3 buffer */ |
| #endif |
| audio_record(rec_create_filename(path_buffer)); |
| break; |
| case RECORDING_CMD_START_NEWFILE: |
| /* create unique filename and start recording*/ |
| pm_reset_clipcount(); |
| pm_activate_clipcount(true); /* just to be sure */ |
| audio_new_file(rec_create_filename(path_buffer)); |
| break; |
| case RECORDING_CMD_PAUSE: |
| pm_activate_clipcount(false); |
| audio_pause_recording(); |
| break; |
| case RECORDING_CMD_RESUME: |
| pm_activate_clipcount(true); |
| audio_resume_recording(); |
| break; |
| } |
| } |
| |
| /* used in trigger_listerner and recording_screen */ |
| static unsigned int last_seconds = 0; |
| |
| /** |
| * Callback function so that the peak meter code can send an event |
| * to this application. This function can be passed to |
| * peak_meter_set_trigger_listener in order to activate the trigger. |
| */ |
| static void trigger_listener(int trigger_status) |
| { |
| switch (trigger_status) |
| { |
| case TRIG_GO: |
| if(!(audio_status() & AUDIO_STATUS_RECORD)) |
| { |
| rec_status |= RCSTAT_HAVE_RECORDED; |
| rec_command(RECORDING_CMD_START); |
| #if CONFIG_CODEC != SWCODEC |
| /* give control to mpeg thread so that it can start |
| recording */ |
| yield(); yield(); yield(); |
| #endif |
| } |
| |
| /* if we're already recording this is a retrigger */ |
| else |
| { |
| if((audio_status() & AUDIO_STATUS_PAUSE) && |
| (global_settings.rec_trigger_type == TRIG_TYPE_PAUSE)) |
| { |
| rec_command(RECORDING_CMD_RESUME); |
| } |
| /* New file on trig start*/ |
| else if (global_settings.rec_trigger_type != TRIG_TYPE_NEW_FILE) |
| { |
| rec_command(RECORDING_CMD_START_NEWFILE); |
| /* tell recording_screen to reset the time */ |
| last_seconds = 0; |
| } |
| } |
| break; |
| |
| /* A _change_ to TRIG_READY means the current recording has stopped */ |
| case TRIG_READY: |
| if(audio_status() & AUDIO_STATUS_RECORD) |
| { |
| switch(global_settings.rec_trigger_type) |
| { |
| case TRIG_TYPE_STOP: /* Stop */ |
| rec_command(RECORDING_CMD_STOP); |
| break; |
| |
| case TRIG_TYPE_PAUSE: /* Pause */ |
| rec_command(RECORDING_CMD_PAUSE); |
| break; |
| |
| case TRIG_TYPE_NEW_FILE: /* New file on trig stop*/ |
| rec_command(RECORDING_CMD_START_NEWFILE); |
| /* tell recording_screen to reset the time */ |
| last_seconds = 0; |
| break; |
| |
| case 3: /* Stop and shutdown */ |
| rec_command(RECORDING_CMD_STOP_SHUTDOWN); |
| break; |
| } |
| |
| if (global_settings.rec_trigger_mode != TRIG_MODE_REARM) |
| { |
| peak_meter_set_trigger_listener(NULL); |
| peak_meter_trigger(false); |
| } |
| } |
| break; |
| } |
| } |
| |
| bool recording_start_automatic = false; |
| |
| bool recording_screen(bool no_source) |
| { |
| long button; |
| bool done = false; |
| char buf[32]; |
| char buf2[32]; |
| int w, h; |
| int update_countdown = 1; |
| unsigned int seconds; |
| int hours, minutes; |
| char filename[13]; |
| int last_audio_stat = -1; |
| int audio_stat; |
| #if CONFIG_CODEC == SWCODEC |
| int warning_counter = 0; |
| #define WARNING_PERIOD 7 |
| #endif |
| #ifdef HAVE_FMRADIO_REC |
| /* Radio is left on if: |
| * 1) Is was on at the start and the initial source is FM Radio |
| * 2) 1) and the source was never changed to something else |
| */ |
| int radio_status = (global_settings.rec_source != AUDIO_SRC_FMRADIO) ? |
| FMRADIO_OFF : get_radio_status(); |
| #endif |
| #if (CONFIG_LED == LED_REAL) |
| bool led_state = false; |
| int led_countdown = 2; |
| #endif |
| #ifdef HAVE_AGC |
| bool peak_read = false; |
| bool peak_valid = false; |
| int peak_l, peak_r; |
| int balance = 0; |
| bool display_agc[NB_SCREENS]; |
| #endif |
| int line[NB_SCREENS]; |
| int i; |
| int filename_offset[NB_SCREENS]; |
| int pm_y[NB_SCREENS]; |
| int trig_xpos[NB_SCREENS]; |
| int trig_ypos[NB_SCREENS]; |
| int trig_width[NB_SCREENS]; |
| /* pm_x = offset pm to put clipcount in front. |
| Use lcd_getstringsize() when not using SYSFONT */ |
| int pm_x = global_settings.peak_meter_clipcounter ? 30 : 0; |
| |
| static const unsigned char *byte_units[] = { |
| ID2P(LANG_BYTE), |
| ID2P(LANG_KILOBYTE), |
| ID2P(LANG_MEGABYTE), |
| ID2P(LANG_GIGABYTE) |
| }; |
| |
| int base_style = STYLE_INVERT; |
| int style; |
| struct viewport vp[NB_SCREENS]; |
| int ymargin = global_settings.cursor_style?0:10; |
| #ifdef HAVE_LCD_COLOR |
| if (global_settings.cursor_style == 2) { |
| base_style |= STYLE_COLORBAR; |
| } |
| else if (global_settings.cursor_style == 3) { |
| base_style |= STYLE_GRADIENT; |
| } |
| #endif |
| |
| struct audio_recording_options rec_options; |
| rec_status = RCSTAT_IN_RECSCREEN; |
| |
| if (rec_create_directory() < 0) |
| { |
| rec_status = 0; |
| return false; |
| } |
| |
| cursor = 0; |
| #if (CONFIG_LED == LED_REAL) && !defined(SIMULATOR) |
| ata_set_led_enabled(false); |
| #endif |
| |
| #if CONFIG_CODEC == SWCODEC |
| /* recording_menu gets messed up: so prevent manus talking */ |
| talk_disable(true); |
| /* audio_init_recording stops anything playing when it takes the audio |
| buffer */ |
| #else |
| /* Yes, we use the D/A for monitoring */ |
| peak_meter_enabled = true; |
| peak_meter_playback(true); |
| #endif |
| |
| audio_init_recording(0); |
| sound_set_volume(global_settings.volume); |
| |
| #ifdef HAVE_AGC |
| peak_meter_get_peakhold(&peak_l, &peak_r); |
| #endif |
| |
| rec_init_recording_options(&rec_options); |
| rec_set_recording_options(&rec_options); |
| |
| set_gain(); |
| |
| #if CONFIG_RTC == 0 |
| /* Create new filename for recording start */ |
| rec_init_filename(); |
| #endif |
| |
| pm_reset_clipcount(); |
| pm_activate_clipcount(false); |
| settings_apply_trigger(); |
| |
| #ifdef HAVE_AGC |
| agc_preset_str[0] = str(LANG_SYSFONT_OFF); |
| agc_preset_str[1] = str(LANG_SYSFONT_AGC_SAFETY); |
| agc_preset_str[2] = str(LANG_SYSFONT_AGC_LIVE); |
| agc_preset_str[3] = str(LANG_SYSFONT_AGC_DJSET); |
| agc_preset_str[4] = str(LANG_SYSFONT_AGC_MEDIUM); |
| agc_preset_str[5] = str(LANG_SYSFONT_AGC_VOICE); |
| if (global_settings.rec_source == AUDIO_SRC_MIC) { |
| agc_preset = global_settings.rec_agc_preset_mic; |
| agc_maxgain = global_settings.rec_agc_maxgain_mic; |
| } |
| else { |
| agc_preset = global_settings.rec_agc_preset_line; |
| agc_maxgain = global_settings.rec_agc_maxgain_line; |
| } |
| #endif /* HAVE_AGC */ |
| |
| FOR_NB_SCREENS(i) |
| { |
| viewport_set_defaults(&vp[i], i); |
| vp[i].font = FONT_SYSFIXED; |
| screens[i].set_viewport(&vp[i]); |
| screens[i].getstringsize("M", &w, &h); |
| filename_offset[i] = ((vp[i].height >= 80) ? 1 : 0); |
| pm_y[i] = h * (2 + filename_offset[i]); |
| } |
| |
| #ifdef HAVE_REMOTE_LCD |
| if (!remote_display_on) |
| { |
| screens[1].clear_display(); |
| snprintf(buf, sizeof(buf), str(LANG_REMOTE_LCD_ON)); |
| screens[1].puts((vp[1].width/w - strlen(buf))/2 + 1, |
| vp[1].height/(h*2) + 1, buf); |
| screens[1].update(); |
| gui_syncsplash(0, str(LANG_REMOTE_LCD_OFF)); |
| } |
| #endif |
| |
| while(!done) |
| { |
| audio_stat = audio_status(); |
| |
| #if (CONFIG_LED == LED_REAL) |
| |
| /* |
| * Flash the LED while waiting to record. Turn it on while |
| * recording. |
| */ |
| if(audio_stat & AUDIO_STATUS_RECORD) |
| { |
| if (audio_stat & AUDIO_STATUS_PAUSE) |
| { |
| if (--led_countdown <= 0) |
| { |
| led_state = !led_state; |
| led(led_state); |
| led_countdown = 2; |
| } |
| } |
| else |
| { |
| /* trigger is on in status TRIG_READY (no check needed) */ |
| led(true); |
| } |
| } |
| else |
| { |
| int trigStat = peak_meter_trigger_status(); |
| /* |
| * other trigger stati than trig_off and trig_steady |
| * already imply that we are recording. |
| */ |
| if (trigStat == TRIG_STEADY) |
| { |
| if (--led_countdown <= 0) |
| { |
| led_state = !led_state; |
| led(led_state); |
| led_countdown = 2; |
| } |
| } |
| else |
| { |
| /* trigger is on in status TRIG_READY (no check needed) */ |
| led(false); |
| } |
| } |
| #endif /* CONFIG_LED */ |
| |
| /* Wait for a button a while (HZ/10) drawing the peak meter */ |
| button = peak_meter_draw_get_btn(CONTEXT_RECSCREEN, |
| pm_x, pm_y, h * PM_HEIGHT, |
| screen_update); |
| |
| if (last_audio_stat != audio_stat) |
| { |
| if (audio_stat & AUDIO_STATUS_RECORD) |
| { |
| rec_status |= RCSTAT_HAVE_RECORDED; |
| } |
| last_audio_stat = audio_stat; |
| } |
| |
| |
| if (recording_start_automatic) |
| { |
| /* simulate a button press */ |
| button = ACTION_REC_PAUSE; |
| recording_start_automatic = false; |
| } |
| |
| switch(button) |
| { |
| #ifdef HAVE_REMOTE_LCD |
| case ACTION_REC_LCD: |
| if (remote_display_on) |
| { |
| remote_display_on = false; |
| screen_update = 1; |
| screens[1].clear_display(); |
| snprintf(buf, sizeof(buf), str(LANG_REMOTE_LCD_ON)); |
| screens[1].puts((screens[1].width/w - strlen(buf))/2 + 1, |
| screens[1].height/(h*2) + 1, buf); |
| screens[1].update(); |
| gui_syncsplash(0, str(LANG_REMOTE_LCD_OFF)); |
| } |
| else |
| { |
| remote_display_on = true; |
| screen_update = NB_SCREENS; |
| } |
| break; |
| #endif |
| case ACTION_STD_CANCEL: |
| /* turn off the trigger */ |
| peak_meter_trigger(false); |
| peak_meter_set_trigger_listener(NULL); |
| |
| if(audio_stat & AUDIO_STATUS_RECORD) |
| { |
| rec_command(RECORDING_CMD_STOP); |
| } |
| else |
| { |
| #if CONFIG_CODEC != SWCODEC |
| peak_meter_playback(true); |
| peak_meter_enabled = false; |
| #endif |
| done = true; |
| } |
| update_countdown = 1; /* Update immediately */ |
| break; |
| |
| case ACTION_REC_PAUSE: |
| case ACTION_REC_NEWFILE: |
| /* Only act if the mpeg is stopped */ |
| if(!(audio_stat & AUDIO_STATUS_RECORD)) |
| { |
| /* is this manual or triggered recording? */ |
| if ((global_settings.rec_trigger_mode == TRIG_MODE_OFF) || |
| (peak_meter_trigger_status() != TRIG_OFF)) |
| { |
| /* manual recording */ |
| rec_status |= RCSTAT_HAVE_RECORDED; |
| rec_command(RECORDING_CMD_START); |
| last_seconds = 0; |
| if (global_settings.talk_menu) |
| { |
| /* no voice possible here, but a beep */ |
| audio_beep(HZ/2); /* longer beep on start */ |
| } |
| } |
| /* this is triggered recording */ |
| else |
| { |
| /* we don't start recording now, but enable the |
| trigger and let the callback function |
| trigger_listener control when the recording starts */ |
| peak_meter_trigger(true); |
| peak_meter_set_trigger_listener(&trigger_listener); |
| } |
| } |
| else |
| { |
| /*if new file button pressed, start new file */ |
| if (button == ACTION_REC_NEWFILE) |
| { |
| rec_command(RECORDING_CMD_START_NEWFILE); |
| last_seconds = 0; |
| } |
| else |
| /* if pause button pressed, pause or resume */ |
| { |
| if(audio_stat & AUDIO_STATUS_PAUSE) |
| { |
| rec_command(RECORDING_CMD_RESUME); |
| if (global_settings.talk_menu) |
| { |
| /* no voice possible here, but a beep */ |
| audio_beep(HZ/4); /* short beep on resume */ |
| } |
| } |
| else |
| { |
| rec_command(RECORDING_CMD_PAUSE); |
| } |
| } |
| } |
| update_countdown = 1; /* Update immediately */ |
| break; |
| |
| case ACTION_STD_PREV: |
| cursor--; |
| adjust_cursor(); |
| update_countdown = 1; /* Update immediately */ |
| break; |
| |
| case ACTION_STD_NEXT: |
| cursor++; |
| adjust_cursor(); |
| update_countdown = 1; /* Update immediately */ |
| break; |
| |
| case ACTION_SETTINGS_INC: |
| case ACTION_SETTINGS_INCREPEAT: |
| switch(cursor) |
| { |
| case 0: |
| global_settings.volume++; |
| setvol(); |
| break; |
| case 1: |
| if(global_settings.rec_source == AUDIO_SRC_MIC) |
| { |
| if(global_settings.rec_mic_gain < |
| sound_max(SOUND_MIC_GAIN)) |
| global_settings.rec_mic_gain++; |
| } |
| else |
| { |
| if(global_settings.rec_left_gain < |
| sound_max(SOUND_LEFT_GAIN)) |
| global_settings.rec_left_gain++; |
| if(global_settings.rec_right_gain < |
| sound_max(SOUND_RIGHT_GAIN)) |
| global_settings.rec_right_gain++; |
| } |
| break; |
| case 2: |
| if(global_settings.rec_left_gain < |
| sound_max(SOUND_LEFT_GAIN)) |
| global_settings.rec_left_gain++; |
| break; |
| case 3: |
| if(global_settings.rec_right_gain < |
| sound_max(SOUND_RIGHT_GAIN)) |
| global_settings.rec_right_gain++; |
| break; |
| #ifdef HAVE_AGC |
| case 4: |
| agc_preset = MIN(agc_preset + 1, AGC_MODE_SIZE); |
| agc_enable = (agc_preset != 0); |
| if (global_settings.rec_source == AUDIO_SRC_MIC) { |
| global_settings.rec_agc_preset_mic = agc_preset; |
| agc_maxgain = global_settings.rec_agc_maxgain_mic; |
| } else { |
| global_settings.rec_agc_preset_line = agc_preset; |
| agc_maxgain = global_settings.rec_agc_maxgain_line; |
| } |
| break; |
| case 5: |
| if (global_settings.rec_source == AUDIO_SRC_MIC) |
| { |
| agc_maxgain = MIN(agc_maxgain + 1, |
| sound_max(SOUND_MIC_GAIN)); |
| global_settings.rec_agc_maxgain_mic = agc_maxgain; |
| } |
| else |
| { |
| agc_maxgain = MIN(agc_maxgain + 1, |
| sound_max(SOUND_LEFT_GAIN)); |
| global_settings.rec_agc_maxgain_line = agc_maxgain; |
| } |
| break; |
| #endif /* HAVE_AGC */ |
| } |
| set_gain(); |
| update_countdown = 1; /* Update immediately */ |
| break; |
| |
| case ACTION_SETTINGS_DEC: |
| case ACTION_SETTINGS_DECREPEAT: |
| switch(cursor) |
| { |
| case 0: |
| global_settings.volume--; |
| setvol(); |
| break; |
| case 1: |
| if(global_settings.rec_source == AUDIO_SRC_MIC) |
| { |
| if(global_settings.rec_mic_gain > |
| sound_min(SOUND_MIC_GAIN)) |
| global_settings.rec_mic_gain--; |
| } |
| else |
| { |
| if(global_settings.rec_left_gain > |
| sound_min(SOUND_LEFT_GAIN)) |
| global_settings.rec_left_gain--; |
| if(global_settings.rec_right_gain > |
| sound_min(SOUND_RIGHT_GAIN)) |
| global_settings.rec_right_gain--; |
| } |
| break; |
| case 2: |
| if(global_settings.rec_left_gain > |
| sound_min(SOUND_LEFT_GAIN)) |
| global_settings.rec_left_gain--; |
| break; |
| case 3: |
| if(global_settings.rec_right_gain > |
| sound_min(SOUND_RIGHT_GAIN)) |
| global_settings.rec_right_gain--; |
| break; |
| #ifdef HAVE_AGC |
| case 4: |
| agc_preset = MAX(agc_preset - 1, 0); |
| agc_enable = (agc_preset != 0); |
| if (global_settings.rec_source == AUDIO_SRC_MIC) { |
| global_settings.rec_agc_preset_mic = agc_preset; |
| agc_maxgain = global_settings.rec_agc_maxgain_mic; |
| } else { |
| global_settings.rec_agc_preset_line = agc_preset; |
| agc_maxgain = global_settings.rec_agc_maxgain_line; |
| } |
| break; |
| case 5: |
| if (global_settings.rec_source == AUDIO_SRC_MIC) |
| { |
| agc_maxgain = MAX(agc_maxgain - 1, |
| sound_min(SOUND_MIC_GAIN)); |
| global_settings.rec_agc_maxgain_mic = agc_maxgain; |
| } |
| else |
| { |
| agc_maxgain = MAX(agc_maxgain - 1, |
| sound_min(SOUND_LEFT_GAIN)); |
| global_settings.rec_agc_maxgain_line = agc_maxgain; |
| } |
| break; |
| #endif /* HAVE_AGC */ |
| } |
| set_gain(); |
| update_countdown = 1; /* Update immediately */ |
| break; |
| |
| case ACTION_STD_MENU: |
| #if CONFIG_CODEC == SWCODEC |
| if(!(audio_stat & AUDIO_STATUS_RECORD)) |
| #else |
| if(audio_stat != AUDIO_STATUS_RECORD) |
| #endif |
| { |
| #ifdef HAVE_FMRADIO_REC |
| const int prev_rec_source = global_settings.rec_source; |
| #endif |
| |
| #if (CONFIG_LED == LED_REAL) |
| /* led is restored at begin of loop / end of function */ |
| led(false); |
| #endif |
| if (recording_menu(no_source)) |
| { |
| done = true; |
| rec_status |= RCSTAT_BEEN_IN_USB_MODE; |
| #ifdef HAVE_FMRADIO_REC |
| radio_status = FMRADIO_OFF; |
| #endif |
| } |
| else |
| { |
| #ifdef HAVE_FMRADIO_REC |
| /* If input changes away from FM Radio, radio will |
| remain off when recording screen closes. */ |
| if (global_settings.rec_source != prev_rec_source |
| && prev_rec_source == AUDIO_SRC_FMRADIO) |
| radio_status = FMRADIO_OFF; |
| #endif |
| |
| #if CONFIG_CODEC == SWCODEC |
| /* reinit after submenu exit */ |
| audio_close_recording(); |
| audio_init_recording(0); |
| #endif |
| |
| rec_init_recording_options(&rec_options); |
| rec_set_recording_options(&rec_options); |
| |
| if(rec_create_directory() < 0) |
| { |
| goto rec_abort; |
| } |
| |
| #if CONFIG_CODEC == SWCODEC && CONFIG_RTC == 0 |
| /* If format changed, a new number is required */ |
| rec_init_filename(); |
| #endif |
| |
| #ifdef HAVE_AGC |
| if (global_settings.rec_source == AUDIO_SRC_MIC) { |
| agc_preset = global_settings.rec_agc_preset_mic; |
| agc_maxgain = global_settings.rec_agc_maxgain_mic; |
| } |
| else { |
| agc_preset = global_settings.rec_agc_preset_line; |
| agc_maxgain = global_settings.rec_agc_maxgain_line; |
| } |
| #endif |
| |
| adjust_cursor(); |
| set_gain(); |
| update_countdown = 1; /* Update immediately */ |
| |
| FOR_NB_SCREENS(i) |
| { |
| screens[i].set_viewport(&vp[i]); |
| screens[i].setfont(FONT_SYSFIXED); |
| } |
| } |
| } |
| break; |
| |
| #if CONFIG_KEYPAD == RECORDER_PAD |
| case ACTION_REC_F2: |
| if(audio_stat != AUDIO_STATUS_RECORD) |
| { |
| #if (CONFIG_LED == LED_REAL) |
| /* led is restored at begin of loop / end of function */ |
| led(false); |
| #endif |
| if (f2_rec_screen()) |
| { |
| rec_status |= RCSTAT_HAVE_RECORDED; |
| done = true; |
| } |
| else |
| update_countdown = 1; /* Update immediately */ |
| } |
| break; |
| |
| case ACTION_REC_F3: |
| if(audio_stat & AUDIO_STATUS_RECORD) |
| { |
| rec_command(RECORDING_CMD_START_NEWFILE); |
| last_seconds = 0; |
| } |
| else |
| { |
| #if (CONFIG_LED == LED_REAL) |
| /* led is restored at begin of loop / end of function */ |
| led(false); |
| #endif |
| if (f3_rec_screen()) |
| { |
| rec_status |= RCSTAT_HAVE_RECORDED; |
| done = true; |
| } |
| else |
| update_countdown = 1; /* Update immediately */ |
| } |
| break; |
| #endif /* CONFIG_KEYPAD == RECORDER_PAD */ |
| |
| case SYS_USB_CONNECTED: |
| /* Only accept USB connection when not recording */ |
| if(!(audio_stat & AUDIO_STATUS_RECORD)) |
| { |
| default_event_handler(SYS_USB_CONNECTED); |
| done = true; |
| rec_status |= RCSTAT_BEEN_IN_USB_MODE; |
| #ifdef HAVE_FMRADIO_REC |
| radio_status = FMRADIO_OFF; |
| #endif |
| } |
| break; |
| |
| default: |
| default_event_handler(button); |
| break; |
| } /* end switch */ |
| |
| #ifdef HAVE_AGC |
| peak_read = !peak_read; |
| if (peak_read) { /* every 2nd run of loop */ |
| peak_time++; |
| peak_valid = read_peak_levels(&peak_l, &peak_r, &balance); |
| } |
| |
| /* Handle AGC every 200ms when enabled and peak data is valid */ |
| if (peak_read && agc_enable && peak_valid) |
| auto_gain_control(&peak_l, &peak_r, &balance); |
| #endif |
| |
| FOR_NB_SCREENS(i) |
| screens[i].setfont(FONT_SYSFIXED); |
| |
| seconds = audio_recorded_time() / HZ; |
| |
| update_countdown--; |
| if(update_countdown == 0 || seconds > last_seconds) |
| { |
| unsigned int dseconds, dhours, dminutes; |
| unsigned long num_recorded_bytes, dsize, dmb; |
| int pos = 0; |
| |
| update_countdown = 5; |
| last_seconds = seconds; |
| |
| dseconds = rec_timesplit_seconds(); |
| dsize = rec_sizesplit_bytes(); |
| num_recorded_bytes = audio_num_recorded_bytes(); |
| |
| for(i = 0; i < screen_update; i++) |
| screens[i].clear_display(); |
| |
| style = base_style; |
| |
| #ifdef HAVE_LCD_COLOR |
| /* special action for gradient - set default for 1 line gradient */ |
| if(global_settings.cursor_style == 3) |
| style = base_style | CURLN_PACK(0) | NUMLN_PACK(1); |
| #endif /* HAVE_LCD_COLOR */ |
| |
| #if CONFIG_CODEC == SWCODEC |
| if ((audio_stat & AUDIO_STATUS_WARNING) |
| && (warning_counter++ % WARNING_PERIOD) < WARNING_PERIOD/2) |
| { |
| /* Switch back and forth displaying warning on first available |
| line to ensure visibility - the motion should also help |
| draw attention */ |
| /* Don't use language string unless agreed upon to make this |
| method permanent - could do something in the statusbar */ |
| snprintf(buf, sizeof(buf), "Warning: %08X", |
| pcm_rec_get_warnings()); |
| } |
| else |
| #endif /* CONFIG_CODEC == SWCODEC */ |
| if ((global_settings.rec_sizesplit) && |
| (global_settings.rec_split_method)) |
| { |
| dmb = dsize/1024/1024; |
| snprintf(buf, sizeof(buf), "%s %dMB", |
| str(LANG_SYSFONT_SPLIT_SIZE), dmb); |
| } |
| else |
| { |
| hours = seconds / 3600; |
| minutes = (seconds - (hours * 3600)) / 60; |
| snprintf(buf, sizeof(buf), "%s %02d:%02d:%02d", |
| str(LANG_SYSFONT_RECORDING_TIME), |
| hours, minutes, seconds%60); |
| } |
| |
| for(i = 0; i < screen_update; i++) |
| screens[i].puts(0, 0, buf); |
| |
| if(audio_stat & AUDIO_STATUS_PRERECORD) |
| { |
| snprintf(buf, sizeof(buf), "%s...", |
| str(LANG_SYSFONT_RECORD_PRERECORD)); |
| } |
| else |
| { |
| /* Display the split interval if the record timesplit |
| is active */ |
| if ((global_settings.rec_timesplit) && |
| !(global_settings.rec_split_method)) |
| { |
| /* Display the record timesplit interval rather |
| than the file size if the record timer is |
| active */ |
| dhours = dseconds / 3600; |
| dminutes = (dseconds - (dhours * 3600)) / 60; |
| snprintf(buf, sizeof(buf), "%s %02d:%02d", |
| str(LANG_SYSFONT_RECORD_TIMESPLIT_REC), |
| dhours, dminutes); |
| } |
| else |
| { |
| output_dyn_value(buf2, sizeof buf2, |
| num_recorded_bytes, |
| byte_units, true); |
| snprintf(buf, sizeof(buf), "%s %s", |
| str(LANG_SYSFONT_RECORDING_SIZE), buf2); |
| } |
| } |
| for(i = 0; i < screen_update; i++) |
| screens[i].puts(0, 1, buf); |
| |
| for(i = 0; i < screen_update; i++) |
| { |
| if (filename_offset[i] > 0) |
| { |
| *filename = '\0'; |
| if (audio_stat & AUDIO_STATUS_RECORD) |
| { |
| strncpy(filename, path_buffer + |
| strlen(path_buffer) - 12, 13); |
| filename[12]='\0'; |
| } |
| |
| snprintf(buf, sizeof(buf), "%s %s", |
| str(LANG_SYSFONT_RECORDING_FILENAME), filename); |
| screens[i].puts(0, 2, buf); |
| } |
| } |
| |
| /* We will do file splitting regardless, either at the end of |
| a split interval, or when the filesize approaches the 2GB |
| FAT file size (compatibility) limit. */ |
| if ((audio_stat && !(global_settings.rec_split_method) |
| && global_settings.rec_timesplit && (seconds >= dseconds)) |
| || (audio_stat && global_settings.rec_split_method |
| && global_settings.rec_sizesplit |
| && (num_recorded_bytes >= dsize)) |
| || (num_recorded_bytes >= MAX_FILE_SIZE)) |
| { |
| if (!(global_settings.rec_split_type) |
| || (num_recorded_bytes >= MAX_FILE_SIZE)) |
| { |
| rec_command(RECORDING_CMD_START_NEWFILE); |
| last_seconds = 0; |
| } |
| else |
| { |
| peak_meter_trigger(false); |
| peak_meter_set_trigger_listener(NULL); |
| if( global_settings.rec_split_type == 1) |
| rec_command(RECORDING_CMD_STOP); |
| else |
| rec_command(RECORDING_CMD_STOP_SHUTDOWN); |
| } |
| update_countdown = 1; |
| } |
| |
| /* draw the clipcounter just in front of the peakmeter */ |
| if(global_settings.peak_meter_clipcounter) |
| { |
| char clpstr[32]; |
| snprintf(clpstr, 32, "%4d", pm_get_clipcount()); |
| for(i = 0; i < screen_update; i++) |
| { |
| if(PM_HEIGHT > 1) |
| screens[i].puts(0, 2 + filename_offset[i], |
| str(LANG_SYSFONT_PM_CLIPCOUNT)); |
| screens[i].puts(0, 1 + PM_HEIGHT + filename_offset[i], |
| clpstr); |
| } |
| } |
| |
| snprintf(buf, sizeof(buf), "%s: %s", str(LANG_SYSFONT_VOLUME), |
| fmt_gain(SOUND_VOLUME, |
| global_settings.volume, |
| buf2, sizeof(buf2))); |
| |
| if (global_settings.cursor_style && (pos++ == cursor)) |
| { |
| for(i = 0; i < screen_update; i++) |
| screens[i].puts_style_offset(0, filename_offset[i] + |
| PM_HEIGHT + 2, buf, style,0); |
| } |
| else |
| { |
| for(i = 0; i < screen_update; i++) |
| screens[i].putsxy(ymargin, |
| SYSFONT_HEIGHT*(filename_offset[i]+ |
| PM_HEIGHT + 2), buf); |
| } |
| |
| if(global_settings.rec_source == AUDIO_SRC_MIC) |
| { |
| /* Draw MIC recording gain */ |
| snprintf(buf, sizeof(buf), "%s:%s", str(LANG_SYSFONT_GAIN), |
| fmt_gain(SOUND_MIC_GAIN, |
| global_settings.rec_mic_gain, |
| buf2, sizeof(buf2))); |
| if(global_settings.cursor_style && ((1==cursor)||(2==cursor))) |
| { |
| for(i = 0; i < screen_update; i++) |
| screens[i].puts_style_offset(0, filename_offset[i] + |
| PM_HEIGHT + 3, buf, style,0); |
| } |
| else |
| { |
| for(i = 0; i < screen_update; i++) |
| screens[i].putsxy(ymargin, |
| SYSFONT_HEIGHT*(filename_offset[i] + |
| PM_HEIGHT + 3), buf); |
| } |
| } |
| else if(0 |
| HAVE_LINE_REC_( || global_settings.rec_source == |
| AUDIO_SRC_LINEIN) |
| HAVE_FMRADIO_REC_( || global_settings.rec_source == |
| AUDIO_SRC_FMRADIO) |
| ) |
| { |
| /* Draw LINE or FMRADIO recording gain */ |
| snprintf(buf, sizeof(buf), "%s:%s", |
| str(LANG_SYSFONT_RECORDING_LEFT), |
| fmt_gain(SOUND_LEFT_GAIN, |
| global_settings.rec_left_gain, |
| buf2, sizeof(buf2))); |
| #ifdef HAVE_LCD_COLOR |
| /* special action for gradient - double line gradient - line1 */ |
| if((global_settings.cursor_style == 3) && |
| (1==cursor)) |
| style = base_style | CURLN_PACK(0) | NUMLN_PACK(2); |
| #endif /* HAVE_LCD_COLOR */ |
| if(global_settings.cursor_style && ((1==cursor)||(2==cursor))) |
| { |
| for(i = 0; i < screen_update; i++) |
| screens[i].puts_style_offset(0, filename_offset[i] + |
| PM_HEIGHT + 3, buf, style,0); |
| } |
| else |
| { |
| for(i = 0; i < screen_update; i++) |
| screens[i].putsxy(ymargin, |
| SYSFONT_HEIGHT*(filename_offset[i] + |
| PM_HEIGHT + 3), buf); |
| } |
| |
| snprintf(buf, sizeof(buf), "%s:%s", |
| str(LANG_SYSFONT_RECORDING_RIGHT), |
| fmt_gain(SOUND_RIGHT_GAIN, |
| global_settings.rec_right_gain, |
| buf2, sizeof(buf2))); |
| #ifdef HAVE_LCD_COLOR |
| /* special action for gradient - double line gradient - line2 */ |
| if((global_settings.cursor_style == 3) && |
| (1==cursor)) |
| style = base_style | CURLN_PACK(1) | NUMLN_PACK(2); |
| #endif /* HAVE_LCD_COLOR */ |
| if(global_settings.cursor_style && ((1==cursor)||(3==cursor))) |
| { |
| for(i = 0; i < screen_update; i++) |
| screens[i].puts_style_offset(0, filename_offset[i] + |
| PM_HEIGHT + 4, buf, style,0); |
| } |
| else |
| { |
| for(i = 0; i < screen_update; i++) |
| screens[i].putsxy(ymargin, |
| SYSFONT_HEIGHT*(filename_offset[i] + |
| PM_HEIGHT + 4), buf); |
| } |
| } |
| #ifdef HAVE_LCD_COLOR |
| /* special action for gradient - back to single line gradient */ |
| if(global_settings.cursor_style == 3) |
| style = base_style | CURLN_PACK(0) | NUMLN_PACK(1); |
| #endif /* HAVE_LCD_COLOR */ |
| |
| FOR_NB_SCREENS(i) |
| { |
| switch (global_settings.rec_source) |
| { |
| HAVE_LINE_REC_(case AUDIO_SRC_LINEIN:) |
| HAVE_FMRADIO_REC_(case AUDIO_SRC_FMRADIO:) |
| line[i] = 5; |
| break; |
| |
| case AUDIO_SRC_MIC: |
| line[i] = 4; |
| break; |
| #ifdef HAVE_SPDIF_REC |
| case AUDIO_SRC_SPDIF: |
| line[i] = 3; |
| break; |
| #endif |
| default: |
| line[i] = 5; /* to prevent uninitialisation |
| warnings for line[0] */ |
| break; |
| } /* end switch */ |
| #ifdef HAVE_AGC |
| if (vp[i].height < h * (2 + filename_offset[i] + |
| PM_HEIGHT + line[i])) |
| { |
| line[i] -= 1; |
| display_agc[i] = false; |
| } |
| else |
| display_agc[i] = true; |
| |
| if ((cursor==4) || (cursor==5)) |
| display_agc[i] = true; |
| } |
| |
| /************** AGC test info ****************** |
| snprintf(buf, sizeof(buf), "D:%d U:%d", |
| (agc_droptime+2)/5, (agc_risetime+2)/5); |
| lcd_putsxy(1, LCD_HEIGHT - 8, buf); |
| snprintf(buf, sizeof(buf), "B:%d", |
| (agc_baltime+2)/5); |
| lcd_putsxy(LCD_WIDTH/2 + 3, LCD_HEIGHT - 8, buf); |
| ***********************************************/ |
| |
| if (cursor == 5) |
| snprintf(buf, sizeof(buf), "%s: %s", |
| str(LANG_SYSFONT_RECORDING_AGC_MAXGAIN), |
| fmt_gain(SOUND_LEFT_GAIN, |
| agc_maxgain, buf2, sizeof(buf2))); |
| else if (agc_preset == 0) |
| snprintf(buf, sizeof(buf), "%s: %s", |
| str(LANG_SYSFONT_RECORDING_AGC_PRESET), |
| agc_preset_str[agc_preset]); |
| else if (global_settings.rec_source == AUDIO_SRC_MIC) |
| snprintf(buf, sizeof(buf), "%s: %s%s", |
| str(LANG_SYSFONT_RECORDING_AGC_PRESET), |
| agc_preset_str[agc_preset], |
| fmt_gain(SOUND_LEFT_GAIN, |
| agc_maxgain - |
| global_settings.rec_mic_gain, |
| buf2, sizeof(buf2))); |
| else |
| snprintf(buf, sizeof(buf), "%s: %s%s", |
| str(LANG_SYSFONT_RECORDING_AGC_PRESET), |
| agc_preset_str[agc_preset], |
| fmt_gain(SOUND_LEFT_GAIN, |
| agc_maxgain - |
| (global_settings.rec_left_gain + |
| global_settings.rec_right_gain)/2, |
| buf2, sizeof(buf2))); |
| |
| if(global_settings.cursor_style && ((cursor==4) || (cursor==5))) |
| { |
| for(i = 0; i < screen_update; i++) |
| screens[i].puts_style_offset(0, filename_offset[i] + |
| PM_HEIGHT + line[i], buf, style,0); |
| } |
| else if (global_settings.rec_source == AUDIO_SRC_MIC |
| HAVE_LINE_REC_(|| global_settings.rec_source == |
| AUDIO_SRC_LINEIN) |
| HAVE_FMRADIO_REC_(|| global_settings.rec_source == |
| AUDIO_SRC_FMRADIO) |
| ) |
| { |
| for(i = 0; i < screen_update; i++) { |
| if (display_agc[i]) { |
| screens[i].putsxy(ymargin, |
| SYSFONT_HEIGHT*(filename_offset[i] + |
| PM_HEIGHT + line[i]), buf); |
| } |
| } |
| } |
| |
| if (global_settings.rec_source == AUDIO_SRC_MIC) |
| { |
| if(agc_maxgain < (global_settings.rec_mic_gain)) |
| change_recording_gain(false, true, true); |
| } |
| else |
| { |
| if(agc_maxgain < (global_settings.rec_left_gain)) |
| change_recording_gain(false, true, false); |
| if(agc_maxgain < (global_settings.rec_right_gain)) |
| change_recording_gain(false, false, true); |
| } |
| #else /* !HAVE_AGC */ |
| } |
| #endif /* HAVE_AGC */ |
| |
| if(!global_settings.cursor_style) { |
| switch(cursor) |
| { |
| case 1: |
| for(i = 0; i < screen_update; i++) |
| screen_put_cursorxy(&screens[i], 0, |
| filename_offset[i] + |
| PM_HEIGHT + 3, true); |
| |
| if(global_settings.rec_source != AUDIO_SRC_MIC) |
| { |
| for(i = 0; i < screen_update; i++) |
| screen_put_cursorxy(&screens[i], 0, |
| filename_offset[i] + |
| PM_HEIGHT + 4, true); |
| } |
| break; |
| case 2: |
| for(i = 0; i < screen_update; i++) |
| screen_put_cursorxy(&screens[i], 0, |
| filename_offset[i] + |
| PM_HEIGHT + 3, true); |
| break; |
| case 3: |
| for(i = 0; i < screen_update; i++) |
| screen_put_cursorxy(&screens[i], 0, |
| filename_offset[i] + |
| PM_HEIGHT + 4, true); |
| break; |
| #ifdef HAVE_AGC |
| case 4: |
| case 5: |
| for(i = 0; i < screen_update; i++) |
| screen_put_cursorxy(&screens[i], 0, |
| filename_offset[i] + |
| PM_HEIGHT + line[i], true); |
| break; |
| #endif /* HAVE_AGC */ |
| default: |
| for(i = 0; i < screen_update; i++) |
| screen_put_cursorxy(&screens[i], 0, |
| filename_offset[i] + |
| PM_HEIGHT + 2, true); |
| } |
| } |
| |
| #ifdef HAVE_AGC |
| hist_time++; |
| #endif |
| |
| for(i = 0; i < screen_update; i++) |
| { |
| screens[i].set_viewport(NULL); |
| gui_statusbar_draw(&(statusbars.statusbars[i]), true); |
| screens[i].set_viewport(&vp[i]); |
| peak_meter_screen(&screens[i], pm_x, pm_y[i], h*PM_HEIGHT); |
| screens[i].update(); |
| } |
| |
| /* draw the trigger status */ |
| FOR_NB_SCREENS(i) |
| { |
| trig_width[i] = ((vp[i].height < 64) || |
| ((vp[i].height < 72) && (PM_HEIGHT > 1))) ? |
| screens[i].width - 14 * w : screens[i].width; |
| trig_xpos[i] = screens[i].width - trig_width[i]; |
| trig_ypos[i] = ((vp[i].height < 72) && (PM_HEIGHT > 1)) ? |
| h*2 : |
| h*(1 + filename_offset[i] + PM_HEIGHT + |
| line[i] |
| #ifdef HAVE_AGC |
| + 1 |
| #endif |
| ); |
| } |
| |
| if (peak_meter_trigger_status() != TRIG_OFF) |
| { |
| peak_meter_draw_trig(trig_xpos, trig_ypos, trig_width, |
| screen_update); |
| for(i = 0; i < screen_update; i++){ |
| screens[i].update_rect(trig_xpos[i], trig_ypos[i], |
| trig_width[i] + 2, TRIG_HEIGHT); |
| } |
| } |
| } |
| |
| if(audio_stat & AUDIO_STATUS_ERROR) |
| { |
| done = true; |
| } |
| } /* end while(!done) */ |
| |
| audio_stat = audio_status(); |
| if (audio_stat & AUDIO_STATUS_ERROR) |
| { |
| gui_syncsplash(0, str(LANG_SYSFONT_DISK_FULL)); |
| gui_syncstatusbar_draw(&statusbars, true); |
| |
| FOR_NB_SCREENS(i) |
| screens[i].update(); |
| |
| #if CONFIG_CODEC == SWCODEC |
| /* stop recording - some players like H10 freeze otherwise |
| TO DO: find out why it freezes and fix properly */ |
| rec_command(RECORDING_CMD_STOP); |
| audio_close_recording(); |
| #endif |
| |
| audio_error_clear(); |
| |
| while(1) |
| { |
| if (action_userabort(TIMEOUT_NOBLOCK)) |
| break; |
| } |
| } |
| |
| rec_abort: |
| |
| #if CONFIG_CODEC == SWCODEC |
| rec_command(RECORDING_CMD_STOP); |
| audio_close_recording(); |
| |
| #ifdef HAVE_FMRADIO_REC |
| if (radio_status != FMRADIO_OFF) |
| /* Restore radio playback - radio_status should be unchanged if started |
| through fm radio screen (barring usb connect) */ |
| rec_set_source(AUDIO_SRC_FMRADIO, (radio_status & FMRADIO_PAUSED) ? |
| SRCF_FMRADIO_PAUSED : SRCF_FMRADIO_PLAYING); |
| else |
| #endif |
| /* Go back to playback mode */ |
| rec_set_source(AUDIO_SRC_PLAYBACK, SRCF_PLAYBACK); |
| |
| /* restore talking */ |
| talk_disable(false); |
| #else /* !SWCODEC */ |
| audio_init_playback(); |
| #endif /* CONFIG_CODEC == SWCODEC */ |
| |
| /* make sure the trigger is really turned off */ |
| peak_meter_trigger(false); |
| peak_meter_set_trigger_listener(NULL); |
| |
| rec_status &= ~RCSTAT_IN_RECSCREEN; |
| sound_settings_apply(); |
| |
| FOR_NB_SCREENS(i) |
| screens[i].setfont(FONT_UI); |
| |
| /* if the directory was created or recording happened, make sure the |
| browser is updated */ |
| if (rec_status & (RCSTAT_CREATED_DIRECTORY | RCSTAT_HAVE_RECORDED)) |
| reload_directory(); |
| |
| #if (CONFIG_LED == LED_REAL) && !defined(SIMULATOR) |
| ata_set_led_enabled(true); |
| #endif |
| |
| settings_save(); |
| |
| return (rec_status & RCSTAT_BEEN_IN_USB_MODE) != 0; |
| } /* recording_screen */ |
| |
| #if CONFIG_KEYPAD == RECORDER_PAD |
| static bool f2_rec_screen(void) |
| { |
| static const char* const freq_str[6] = |
| { |
| "44.1kHz", |
| "48kHz", |
| "32kHz", |
| "22.05kHz", |
| "24kHz", |
| "16kHz" |
| }; |
| |
| bool exit = false; |
| bool used = false; |
| int w, h, i; |
| char buf[32]; |
| int button; |
| struct audio_recording_options rec_options; |
| |
| FOR_NB_SCREENS(i) |
| { |
| screens[i].setfont(FONT_SYSFIXED); |
| screens[i].getstringsize("A",&w,&h); |
| } |
| |
| while (!exit) { |
| const char* ptr=NULL; |
| |
| FOR_NB_SCREENS(i) |
| { |
| screens[i].clear_display(); |
| |
| /* Recording quality */ |
| screens[i].putsxy(0, LCD_HEIGHT/2 - h*2, |
| str(LANG_SYSFONT_RECORDING_QUALITY)); |
| } |
| |
| snprintf(buf, sizeof(buf), "%d", global_settings.rec_quality); |
| FOR_NB_SCREENS(i) |
| { |
| screens[i].putsxy(0, LCD_HEIGHT/2-h, buf); |
| screens[i].mono_bitmap(bitmap_icons_7x8[Icon_FastBackward], |
| LCD_WIDTH/2 - 16, LCD_HEIGHT/2 - 4, 7, 8); |
| } |
| |
| /* Frequency */ |
| snprintf(buf, sizeof buf, "%s:", str(LANG_SYSFONT_RECORDING_FREQUENCY)); |
| ptr = freq_str[global_settings.rec_frequency]; |
| FOR_NB_SCREENS(i) |
| { |
| screens[i].getstringsize(buf,&w,&h); |
| screens[i].putsxy((LCD_WIDTH-w)/2, LCD_HEIGHT - h*2, buf); |
| screens[i].getstringsize(ptr, &w, &h); |
| screens[i].putsxy((LCD_WIDTH-w)/2, LCD_HEIGHT - h, ptr); |
| screens[i].mono_bitmap(bitmap_icons_7x8[Icon_DownArrow], |
| LCD_WIDTH/2 - 3, LCD_HEIGHT - h*3, 7, 8); |
| } |
| |
| /* Channel mode */ |
| switch ( global_settings.rec_channels ) { |
| case 0: |
| ptr = str(LANG_SYSFONT_CHANNEL_STEREO); |
| break; |
| |
| case 1: |
| ptr = str(LANG_SYSFONT_CHANNEL_MONO); |
| break; |
| } |
| |
| FOR_NB_SCREENS(i) |
| { |
| screens[i].getstringsize(str(LANG_SYSFONT_CHANNELS), &w, &h); |
| screens[i].putsxy(LCD_WIDTH - w, LCD_HEIGHT/2 - h*2, |
| str(LANG_SYSFONT_CHANNELS)); |
| screens[i].getstringsize(str(LANG_SYSFONT_MODE), &w, &h); |
| screens[i].putsxy(LCD_WIDTH - w, LCD_HEIGHT/2 - h, |
| str(LANG_SYSFONT_MODE)); |
| screens[i].getstringsize(ptr, &w, &h); |
| screens[i].putsxy(LCD_WIDTH - w, LCD_HEIGHT/2, ptr); |
| screens[i].mono_bitmap(bitmap_icons_7x8[Icon_FastForward], |
| LCD_WIDTH/2 + 8, LCD_HEIGHT/2 - 4, 7, 8); |
| |
| screens[i].update(); |
| } |
| |
| button = button_get(true); |
| switch (button) { |
| case BUTTON_LEFT: |
| case BUTTON_F2 | BUTTON_LEFT: |
| global_settings.rec_quality++; |
| if(global_settings.rec_quality > 7) |
| global_settings.rec_quality = 0; |
| used = true; |
| break; |
| |
| case BUTTON_DOWN: |
| case BUTTON_F2 | BUTTON_DOWN: |
| global_settings.rec_frequency++; |
| if(global_settings.rec_frequency > 5) |
| global_settings.rec_frequency = 0; |
| used = true; |
| break; |
| |
| case BUTTON_RIGHT: |
| case BUTTON_F2 | BUTTON_RIGHT: |
| global_settings.rec_channels++; |
| if(global_settings.rec_channels > 1) |
| global_settings.rec_channels = 0; |
| used = true; |
| break; |
| |
| case BUTTON_F2 | BUTTON_REL: |
| if ( used ) |
| exit = true; |
| used = true; |
| break; |
| |
| case BUTTON_F2 | BUTTON_REPEAT: |
| used = true; |
| break; |
| |
| default: |
| if(default_event_handler(button) == SYS_USB_CONNECTED) |
| return true; |
| break; |
| } |
| } |
| |
| rec_init_recording_options(&rec_options); |
| rec_set_recording_options(&rec_options); |
| |
| set_gain(); |
| |
| settings_save(); |
| FOR_NB_SCREENS(i) |
| screens[i].setfont(FONT_UI); |
| |
| return false; |
| } |
| |
| static bool f3_rec_screen(void) |
| { |
| bool exit = false; |
| bool used = false; |
| int w, h, i; |
| int button; |
| char *src_str[] = |
| { |
| str(LANG_SYSFONT_RECORDING_SRC_MIC), |
| str(LANG_SYSFONT_LINE_IN), |
| str(LANG_SYSFONT_RECORDING_SRC_DIGITAL) |
| }; |
| struct audio_recording_options rec_options; |
| |
| FOR_NB_SCREENS(i) |
| { |
| screens[i].setfont(FONT_SYSFIXED); |
| screens[i].getstringsize("A",&w,&h); |
| } |
| |
| while (!exit) { |
| char* ptr=NULL; |
| ptr = src_str[global_settings.rec_source]; |
| FOR_NB_SCREENS(i) |
| { |
| screens[i].clear_display(); |
| |
| /* Recording source */ |
| screens[i].putsxy(0, LCD_HEIGHT/2 - h*2, |
| str(LANG_SYSFONT_RECORDING_SOURCE)); |
| |
| screens[i].getstringsize(ptr, &w, &h); |
| screens[i].putsxy(0, LCD_HEIGHT/2-h, ptr); |
| screens[i].mono_bitmap(bitmap_icons_7x8[Icon_FastBackward], |
| LCD_WIDTH/2 - 16, LCD_HEIGHT/2 - 4, 7, 8); |
| } |
| |
| /* trigger setup */ |
| ptr = str(LANG_SYSFONT_RECORD_TRIGGER); |
| FOR_NB_SCREENS(i) |
| { |
| screens[i].getstringsize(ptr,&w,&h); |
| screens[i].putsxy((LCD_WIDTH-w)/2, LCD_HEIGHT - h*2, ptr); |
| screens[i].mono_bitmap(bitmap_icons_7x8[Icon_DownArrow], |
| LCD_WIDTH/2 - 3, LCD_HEIGHT - h*3, 7, 8); |
| |
| screens[i].update(); |
| } |
| |
| button = button_get(true); |
| switch (button) { |
| case BUTTON_DOWN: |
| case BUTTON_F3 | BUTTON_DOWN: |
| #ifndef SIMULATOR |
| rectrigger(); |
| settings_apply_trigger(); |
| #endif |
| exit = true; |
| break; |
| |
| case BUTTON_LEFT: |
| case BUTTON_F3 | BUTTON_LEFT: |
| global_settings.rec_source++; |
| if(global_settings.rec_source > AUDIO_SRC_MAX) |
| global_settings.rec_source = 0; |
| used = true; |
| break; |
| |
| case BUTTON_F3 | BUTTON_REL: |
| if ( used ) |
| exit = true; |
| used = true; |
| break; |
| |
| case BUTTON_F3 | BUTTON_REPEAT: |
| used = true; |
| break; |
| |
| default: |
| if(default_event_handler(button) == SYS_USB_CONNECTED) |
| return true; |
| break; |
| } |
| } |
| |
| rec_init_recording_options(&rec_options); |
| rec_set_recording_options(&rec_options); |
| |
| set_gain(); |
| |
| settings_save(); |
| FOR_NB_SCREENS(i) |
| screens[i].setfont(FONT_UI); |
| |
| return false; |
| } |
| #endif /* CONFIG_KEYPAD == RECORDER_PAD */ |
| |
| #if CONFIG_CODEC == SWCODEC |
| void audio_beep(int duration) |
| { |
| /* dummy */ |
| (void)duration; |
| } |
| |
| #ifdef SIMULATOR |
| /* stubs for recording sim */ |
| void audio_init_recording(unsigned int buffer_offset) |
| { |
| buffer_offset = buffer_offset; |
| } |
| |
| void audio_close_recording(void) |
| { |
| } |
| |
| unsigned long pcm_rec_get_warnings(void) |
| { |
| return 0; |
| } |
| |
| unsigned long audio_recorded_time(void) |
| { |
| return 123; |
| } |
| |
| unsigned long audio_num_recorded_bytes(void) |
| { |
| return 5 * 1024 * 1024; |
| } |
| |
| void rec_set_source(int source, unsigned flags) |
| { |
| source = source; |
| flags = flags; |
| } |
| |
| void audio_set_recording_options(struct audio_recording_options *options) |
| { |
| options = options; |
| } |
| |
| void audio_set_recording_gain(int left, int right, int type) |
| { |
| left = left; |
| right = right; |
| type = type; |
| } |
| |
| void audio_record(const char *filename) |
| { |
| filename = filename; |
| } |
| |
| void audio_new_file(const char *filename) |
| { |
| filename = filename; |
| } |
| |
| void audio_stop_recording(void) |
| { |
| } |
| |
| void audio_pause_recording(void) |
| { |
| } |
| |
| void audio_resume_recording(void) |
| { |
| } |
| |
| #endif /* #ifdef SIMULATOR */ |
| #endif /* #ifdef CONFIG_CODEC == SWCODEC */ |
| |
| #endif /* HAVE_RECORDING */ |