50a6ca39ad
This is to a) to cleanup firmware/common and firmware/include a bit, but also b) for Rockbox as an application which should use the host system's c library and headers, separating makes it easy to exclude our files from the build. git-svn-id: svn://svn.rockbox.org/rockbox/trunk@25850 a1c6a512-1295-4272-9138-f99709370657
1437 lines
45 KiB
C
1437 lines
45 KiB
C
/***************************************************************************
|
|
* __________ __ ___.
|
|
* Open \______ \ ____ ____ | | _\_ |__ _______ ___
|
|
* Source | _// _ \_/ ___\| |/ /| __ \ / _ \ \/ /
|
|
* Jukebox | | ( <_> ) \___| < | \_\ ( <_> > < <
|
|
* Firmware |____|_ /\____/ \___ >__|_ \|___ /\____/__/\_ \
|
|
* \/ \/ \/ \/ \/
|
|
* $Id$
|
|
*
|
|
* Copyright (C) 2002 by Philipp Pertermann
|
|
*
|
|
* 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.
|
|
*
|
|
****************************************************************************/
|
|
#ifdef SIMULATOR
|
|
#include <stdlib.h> /* sim uses rand for peakmeter simulation */
|
|
#endif
|
|
#include "config.h"
|
|
#include "mas.h"
|
|
#include "thread.h"
|
|
#include "kernel.h"
|
|
#include "settings.h"
|
|
#include "storage.h"
|
|
#include "lcd.h"
|
|
#include "scrollbar.h"
|
|
#include "button.h"
|
|
#include "system.h"
|
|
#include "font.h"
|
|
#include "icons.h"
|
|
#include "lang.h"
|
|
#include "peakmeter.h"
|
|
#include "audio.h"
|
|
#include "screen_access.h"
|
|
#ifdef HAVE_BACKLIGHT
|
|
#include "backlight.h"
|
|
#endif
|
|
#include "action.h"
|
|
|
|
#if CONFIG_CODEC == SWCODEC
|
|
#include "pcm.h"
|
|
|
|
#ifdef HAVE_RECORDING
|
|
#include "pcm_record.h"
|
|
#endif
|
|
|
|
static bool pm_playback = true; /* selects between playback and recording peaks */
|
|
#endif
|
|
|
|
static struct meter_scales scales[NB_SCREENS];
|
|
|
|
#if !defined(SIMULATOR) && CONFIG_CODEC != SWCODEC
|
|
/* Data source */
|
|
static int pm_src_left = MAS_REG_DQPEAK_L;
|
|
static int pm_src_right = MAS_REG_DQPEAK_R;
|
|
#endif
|
|
|
|
/* Current values and cumulation */
|
|
static int pm_cur_left; /* current values (last peak_meter_peek) */
|
|
static int pm_cur_right;
|
|
static int pm_max_left; /* maximum values between peak meter draws */
|
|
static int pm_max_right;
|
|
#if defined(HAVE_AGC) || defined(HAVE_RECORDING_HISTOGRAM)
|
|
static int pm_peakhold_left; /* max. peak values between peakhold calls */
|
|
static int pm_peakhold_right; /* used for AGC and histogram display */
|
|
#endif
|
|
|
|
/* Clip hold */
|
|
static bool pm_clip_left = false; /* when true a clip has occurred */
|
|
static bool pm_clip_right = false;
|
|
static long pm_clip_timeout_l; /* clip hold timeouts */
|
|
static long pm_clip_timeout_r;
|
|
|
|
/* Temporarily en- / disables peak meter. This is especially for external
|
|
applications to detect if the peak_meter is in use and needs drawing at all */
|
|
bool peak_meter_enabled = true;
|
|
|
|
/** Parameters **/
|
|
/* Range */
|
|
static unsigned short peak_meter_range_min; /* minimum of range in samples */
|
|
static unsigned short peak_meter_range_max; /* maximum of range in samples */
|
|
static unsigned short pm_range; /* range width in samples */
|
|
static bool pm_use_dbfs = true; /* true if peakmeter displays dBfs */
|
|
static bool level_check; /* true if peeked at peakmeter before drawing */
|
|
static unsigned short pm_db_min = 0; /* minimum of range in 1/100 dB */
|
|
static unsigned short pm_db_max = 9000; /* maximum of range in 1/100 dB */
|
|
static unsigned short pm_db_range = 9000; /* range width in 1/100 dB */
|
|
/* Timing behaviour */
|
|
static int pm_peak_hold = 1; /* peak hold timeout index */
|
|
static int pm_peak_release = 8; /* peak release in units per read */
|
|
static int pm_clip_hold = 16; /* clip hold timeout index */
|
|
static bool pm_clip_eternal = false; /* true if clip timeout is disabled */
|
|
|
|
#ifdef HAVE_RECORDING
|
|
static unsigned short trig_strt_threshold;
|
|
static long trig_strt_duration;
|
|
static long trig_strt_dropout;
|
|
static unsigned short trig_stp_threshold;
|
|
static long trig_stp_hold;
|
|
static long trig_rstrt_gap;
|
|
|
|
/* point in time when the threshold was exceeded */
|
|
static long trig_hightime;
|
|
|
|
/* point in time when the volume fell below the threshold*/
|
|
static long trig_lowtime;
|
|
|
|
/* The output value of the trigger. See TRIG_XXX constants for valid values */
|
|
static int trig_status = TRIG_OFF;
|
|
|
|
static void (*trigger_listener)(int) = NULL;
|
|
|
|
/* clipping counter (only used for recording) */
|
|
static unsigned int pm_clipcount = 0; /* clipping count */
|
|
static bool pm_clipcount_active = false; /* counting or not */
|
|
#endif
|
|
|
|
/* debug only */
|
|
#ifdef PM_DEBUG
|
|
static int peek_calls = 0;
|
|
|
|
#define PEEKS_PER_DRAW_SIZE 40
|
|
static unsigned int peeks_per_redraw[PEEKS_PER_DRAW_SIZE];
|
|
|
|
#define TICKS_PER_DRAW_SIZE 20
|
|
static unsigned int ticks_per_redraw[TICKS_PER_DRAW_SIZE];
|
|
#endif
|
|
|
|
static void peak_meter_draw(struct screen *display, struct meter_scales *meter_scales,
|
|
int x, int y, int width, int height);
|
|
|
|
/* time out values for max */
|
|
static const short peak_time_out[] = {
|
|
0 * HZ, HZ / 5, 30, HZ / 2, HZ, 2 * HZ,
|
|
3 * HZ, 4 * HZ, 5 * HZ, 6 * HZ, 7 * HZ, 8 * HZ,
|
|
9 * HZ, 10 * HZ, 15 * HZ, 20 * HZ, 30 * HZ, 60 * HZ
|
|
};
|
|
|
|
/* time out values for clip */
|
|
static const long clip_time_out[] = {
|
|
0 * HZ, 1 * HZ, 2 * HZ, 3 * HZ, 4 * HZ, 5 * HZ,
|
|
6 * HZ, 7 * HZ, 8 * HZ, 9 * HZ, 10 * HZ, 15 * HZ,
|
|
20 * HZ, 25 * HZ, 30 * HZ, 45 * HZ, 60 * HZ, 90 * HZ,
|
|
120 * HZ, 180 * HZ, 300 * HZ, 600L * HZ, 1200L * HZ,
|
|
2700L * HZ, 5400L * HZ
|
|
};
|
|
|
|
/* precalculated peak values that represent magical
|
|
dBfs values. Used to draw the scale */
|
|
static const short db_scale_src_values[DB_SCALE_SRC_VALUES_SIZE] = {
|
|
32736, /* 0 db */
|
|
22752, /* - 3 db */
|
|
16640, /* - 6 db */
|
|
11648, /* - 9 db */
|
|
8320, /* -12 db */
|
|
4364, /* -18 db */
|
|
2064, /* -24 db */
|
|
1194, /* -30 db */
|
|
363, /* -40 db */
|
|
101, /* -50 db */
|
|
34, /* -60 db */
|
|
0, /* -inf */
|
|
};
|
|
|
|
static int db_scale_count = DB_SCALE_SRC_VALUES_SIZE;
|
|
|
|
/**
|
|
* Calculates dB Value for the peak meter, uses peak value as input
|
|
* @param int sample - The input value
|
|
* Make sure that 0 <= value < SAMPLE_RANGE
|
|
*
|
|
* @return int - The 2 digit fixed point result of the euation
|
|
* 20 * log (sample / SAMPLE_RANGE) + 90
|
|
* Output range is 0-9000 (that is 0.0 - 90.0 dB).
|
|
* Normally 0dB is full scale, here it is shifted +90dB.
|
|
* The calculation is based on the results of a linear
|
|
* approximation tool written specifically for this problem
|
|
* by Andreas Zwirtes (radhard@gmx.de). The result has an
|
|
* accurracy of better than 2%. It is highly runtime optimized,
|
|
* the cascading if-clauses do an successive approximation on
|
|
* the input value. This avoids big lookup-tables and
|
|
* for-loops.
|
|
* Improved by Jvo Studer for errors < 0.2dB for critical
|
|
* range of -12dB to 0dB (78.0 to 90.0dB).
|
|
*/
|
|
|
|
int calc_db (int isample)
|
|
{
|
|
/* return n+m*(isample-istart)/100 */
|
|
int n;
|
|
long m;
|
|
int istart;
|
|
|
|
if (isample < 2308) { /* Range 1-5 */
|
|
|
|
if (isample < 115) { /* Range 1-3 */
|
|
|
|
if (isample < 24) {
|
|
|
|
if (isample < 5) {
|
|
istart = 1; /* Range 1 */
|
|
n = 98;
|
|
m = 34950;
|
|
}
|
|
else {
|
|
istart = 5; /* Range 2 */
|
|
n = 1496;
|
|
m = 7168;
|
|
}
|
|
}
|
|
else {
|
|
istart = 24; /* Range 3 */
|
|
n = 2858;
|
|
m = 1498;
|
|
}
|
|
}
|
|
else { /* Range 4-5 */
|
|
|
|
if (isample < 534) {
|
|
istart = 114; /* Range 4 */
|
|
n = 4207;
|
|
m = 319;
|
|
}
|
|
else {
|
|
istart = 588; /* Range 5 */
|
|
n = 5583;
|
|
m = 69;
|
|
}
|
|
}
|
|
}
|
|
|
|
else { /* Range 6-9 */
|
|
|
|
if (isample < 12932) {
|
|
|
|
if (isample < 6394) {
|
|
istart = 2608; /* Range 6 */
|
|
n = 6832;
|
|
m = 21;
|
|
}
|
|
else {
|
|
istart = 7000; /* Range 7 */
|
|
n = 7682;
|
|
m = 9;
|
|
}
|
|
}
|
|
else {
|
|
|
|
if (isample < 22450) {
|
|
istart = 13000; /* Range 8 */
|
|
n = 8219;
|
|
m = 5;
|
|
}
|
|
else {
|
|
istart = 22636; /* Range 9 */
|
|
n = 8697;
|
|
m = 3;
|
|
}
|
|
}
|
|
}
|
|
|
|
return n + (m * (long)(isample - istart)) / 100L;
|
|
}
|
|
|
|
|
|
/**
|
|
* A helper function for peak_meter_db2sample. Don't call it separately but
|
|
* use peak_meter_db2sample. If one or both of min and max are outside the
|
|
* range 0 <= min (or max) < 8961 the behaviour of this function is
|
|
* undefined. It may not return.
|
|
* @param int min - The minimum of the value range that is searched.
|
|
* @param int max - The maximum of the value range that is searched.
|
|
* @param int db - The value in dBfs * (-100) for which the according
|
|
* minimal peak sample is searched.
|
|
* @return int - A linear volume value with 0 <= value < MAX_PEAK
|
|
*/
|
|
static int db_to_sample_bin_search(int min, int max, int db)
|
|
{
|
|
int test = min + (max - min) / 2;
|
|
|
|
if (min < max) {
|
|
if (calc_db(test) < db) {
|
|
test = db_to_sample_bin_search(test, max, db);
|
|
} else {
|
|
if (calc_db(test-1) > db) {
|
|
test = db_to_sample_bin_search(min, test, db);
|
|
}
|
|
}
|
|
}
|
|
return test;
|
|
}
|
|
|
|
/**
|
|
* Converts a value representing dBfs to a linear
|
|
* scaled volume info as it is used by the MAS.
|
|
* An incredibly inefficiant function which is
|
|
* the vague inverse of calc_db. This really
|
|
* should be replaced by something better soon.
|
|
*
|
|
* @param int db - A dBfs * 100 value with
|
|
* -9000 < value <= 0
|
|
* @return int - The return value is in the range of
|
|
* 0 <= return value < MAX_PEAK
|
|
*/
|
|
int peak_meter_db2sample(int db)
|
|
{
|
|
int retval = 0;
|
|
|
|
/* what is the maximum pseudo db value */
|
|
int max_peak_db = calc_db(MAX_PEAK - 1);
|
|
|
|
/* range check: db value to big */
|
|
if (max_peak_db + db < 0) {
|
|
retval = 0;
|
|
}
|
|
|
|
/* range check: db value too small */
|
|
else if (max_peak_db + db >= max_peak_db) {
|
|
retval = MAX_PEAK -1;
|
|
}
|
|
|
|
/* value in range: find the matching linear value */
|
|
else {
|
|
retval = db_to_sample_bin_search(0, MAX_PEAK, max_peak_db + db);
|
|
|
|
/* as this is a dirty function anyway, we want to adjust the
|
|
full scale hit manually to avoid users complaining that when
|
|
they adjust maximum for 0 dBfs and display it in percent it
|
|
shows 99%. That is due to precision loss and this is the
|
|
optical fix */
|
|
}
|
|
|
|
return retval;
|
|
}
|
|
|
|
/**
|
|
* Set the min value for restriction of the value range.
|
|
* @param int newmin - depending whether dBfs is used
|
|
* newmin is a value in dBfs * 100 or in linear percent values.
|
|
* for dBfs: -9000 < newmin <= 0
|
|
* for linear: 0 <= newmin <= 100
|
|
*/
|
|
static void peak_meter_set_min(int newmin)
|
|
{
|
|
if (pm_use_dbfs) {
|
|
peak_meter_range_min = peak_meter_db2sample(newmin);
|
|
|
|
} else {
|
|
if (newmin < peak_meter_range_max) {
|
|
peak_meter_range_min = newmin * MAX_PEAK / 100;
|
|
}
|
|
}
|
|
|
|
pm_range = peak_meter_range_max - peak_meter_range_min;
|
|
|
|
/* Avoid division by zero. */
|
|
if (pm_range == 0) {
|
|
pm_range = 1;
|
|
}
|
|
|
|
pm_db_min = calc_db(peak_meter_range_min);
|
|
pm_db_range = pm_db_max - pm_db_min;
|
|
int i;
|
|
FOR_NB_SCREENS(i)
|
|
scales[i].db_scale_valid = false;
|
|
}
|
|
|
|
/**
|
|
* Returns the minimum value of the range the meter
|
|
* displays. If the scale is set to dBfs it returns
|
|
* dBfs values * 100 or linear percent values.
|
|
* @return: using dBfs : -9000 < value <= 0
|
|
* using linear scale: 0 <= value <= 100
|
|
*/
|
|
int peak_meter_get_min(void)
|
|
{
|
|
int retval = 0;
|
|
if (pm_use_dbfs) {
|
|
retval = calc_db(peak_meter_range_min) - calc_db(MAX_PEAK - 1);
|
|
} else {
|
|
retval = peak_meter_range_min * 100 / MAX_PEAK;
|
|
}
|
|
return retval;
|
|
}
|
|
|
|
/**
|
|
* Set the max value for restriction of the value range.
|
|
* @param int newmax - depending wether dBfs is used
|
|
* newmax is a value in dBfs * 100 or in linear percent values.
|
|
* for dBfs: -9000 < newmax <= 0
|
|
* for linear: 0 <= newmax <= 100
|
|
*/
|
|
static void peak_meter_set_max(int newmax)
|
|
{
|
|
if (pm_use_dbfs) {
|
|
peak_meter_range_max = peak_meter_db2sample(newmax);
|
|
} else {
|
|
if (newmax > peak_meter_range_min) {
|
|
peak_meter_range_max = newmax * MAX_PEAK / 100;
|
|
}
|
|
}
|
|
|
|
pm_range = peak_meter_range_max - peak_meter_range_min;
|
|
|
|
/* Avoid division by zero. */
|
|
if (pm_range == 0) {
|
|
pm_range = 1;
|
|
}
|
|
|
|
pm_db_max = calc_db(peak_meter_range_max);
|
|
pm_db_range = pm_db_max - pm_db_min;
|
|
int i;
|
|
FOR_NB_SCREENS(i)
|
|
scales[i].db_scale_valid = false;
|
|
}
|
|
|
|
/**
|
|
* Returns the minimum value of the range the meter
|
|
* displays. If the scale is set to dBfs it returns
|
|
* dBfs values * 100 or linear percent values
|
|
* @return: using dBfs : -9000 < value <= 0
|
|
* using linear scale: 0 <= value <= 100
|
|
*/
|
|
int peak_meter_get_max(void)
|
|
{
|
|
int retval = 0;
|
|
if (pm_use_dbfs) {
|
|
retval = calc_db(peak_meter_range_max) - calc_db(MAX_PEAK - 1);
|
|
} else {
|
|
retval = peak_meter_range_max * 100 / MAX_PEAK;
|
|
}
|
|
return retval;
|
|
}
|
|
|
|
/**
|
|
* Returns whether the meter is currently displaying dBfs or percent values.
|
|
* @return bool - true if the meter is displaying dBfs
|
|
false if the meter is displaying percent values.
|
|
*/
|
|
bool peak_meter_get_use_dbfs(void)
|
|
{
|
|
return pm_use_dbfs;
|
|
}
|
|
|
|
/**
|
|
* Specifies whether the values displayed are scaled
|
|
* as dBfs or as linear percent values.
|
|
* @param use - set to true for dBfs,
|
|
* set to false for linear scaling in percent
|
|
*/
|
|
void peak_meter_set_use_dbfs(bool use)
|
|
{
|
|
int i;
|
|
pm_use_dbfs = use;
|
|
FOR_NB_SCREENS(i)
|
|
scales[i].db_scale_valid = false;
|
|
}
|
|
|
|
/**
|
|
* Initialize the range of the meter. Only values
|
|
* that are in the range of [range_min ... range_max]
|
|
* are displayed.
|
|
* @param bool dbfs - set to true for dBfs,
|
|
* set to false for linear scaling in percent
|
|
* @param int range_min - Specifies the lower value of the range.
|
|
* Pass a value dBfs * 100 when dbfs is set to true.
|
|
* Pass a percent value when dbfs is set to false.
|
|
* @param int range_max - Specifies the upper value of the range.
|
|
* Pass a value dBfs * 100 when dbfs is set to true.
|
|
* Pass a percent value when dbfs is set to false.
|
|
*/
|
|
void peak_meter_init_range( bool dbfs, int range_min, int range_max)
|
|
{
|
|
pm_use_dbfs = dbfs;
|
|
peak_meter_set_min(range_min);
|
|
peak_meter_set_max(range_max);
|
|
}
|
|
|
|
/**
|
|
* Initialize the peak meter with all relevant values concerning times.
|
|
* @param int release - Set the maximum amount of pixels the meter is allowed
|
|
* to decrease with each redraw
|
|
* @param int hold - Select the time preset for the time the peak indicator
|
|
* is reset after a peak occurred. The preset values are
|
|
* stored in peak_time_out.
|
|
* @param int clip_hold - Select the time preset for the time the peak
|
|
* indicator is reset after a peak occurred. The preset
|
|
* values are stored in clip_time_out.
|
|
*/
|
|
void peak_meter_init_times(int release, int hold, int clip_hold)
|
|
{
|
|
pm_peak_hold = hold;
|
|
pm_peak_release = release;
|
|
pm_clip_hold = clip_hold;
|
|
}
|
|
|
|
#ifdef HAVE_RECORDING
|
|
/**
|
|
* Enable/disable clip counting
|
|
*/
|
|
void pm_activate_clipcount(bool active)
|
|
{
|
|
pm_clipcount_active = active;
|
|
}
|
|
|
|
/**
|
|
* Get clipping counter value
|
|
*/
|
|
int pm_get_clipcount(void)
|
|
{
|
|
return pm_clipcount;
|
|
}
|
|
|
|
/**
|
|
* Set clipping counter to zero (typically at start of recording or playback)
|
|
*/
|
|
void pm_reset_clipcount(void)
|
|
{
|
|
pm_clipcount = 0;
|
|
}
|
|
#endif
|
|
|
|
/**
|
|
* Set the source of the peak meter to playback or to
|
|
* record.
|
|
* @param: bool playback - If true playback peak meter is used.
|
|
* If false recording peak meter is used.
|
|
*/
|
|
void peak_meter_playback(bool playback)
|
|
{
|
|
int i;
|
|
#ifdef SIMULATOR
|
|
(void)playback;
|
|
#elif CONFIG_CODEC == SWCODEC
|
|
pm_playback = playback;
|
|
#else
|
|
if (playback) {
|
|
pm_src_left = MAS_REG_DQPEAK_L;
|
|
pm_src_right = MAS_REG_DQPEAK_R;
|
|
} else {
|
|
pm_src_left = MAS_REG_QPEAK_L;
|
|
pm_src_right = MAS_REG_QPEAK_R;
|
|
}
|
|
#endif
|
|
/* reset the scales just in case recording and playback
|
|
use different viewport sizes. Normally we should be checking viewport
|
|
sizes every time but this will do for now */
|
|
FOR_NB_SCREENS(i)
|
|
scales[i].db_scale_valid = false;
|
|
}
|
|
|
|
#ifdef HAVE_RECORDING
|
|
static void set_trig_status(int new_state)
|
|
{
|
|
if (trig_status != new_state) {
|
|
trig_status = new_state;
|
|
if (trigger_listener != NULL) {
|
|
trigger_listener(trig_status);
|
|
}
|
|
}
|
|
}
|
|
|
|
#endif
|
|
|
|
/**
|
|
* Reads peak values from the MAS, and detects clips. The
|
|
* values are stored in pm_max_left pm_max_right for later
|
|
* evauluation. Consecutive calls to peak_meter_peek detect
|
|
* that ocurred. This function could be used by a thread for
|
|
* busy reading the MAS.
|
|
*/
|
|
void peak_meter_peek(void)
|
|
{
|
|
int left, right;
|
|
#ifdef HAVE_RECORDING
|
|
bool was_clipping = pm_clip_left || pm_clip_right;
|
|
#endif
|
|
/* read current values */
|
|
#if CONFIG_CODEC == SWCODEC
|
|
if (pm_playback)
|
|
pcm_calculate_peaks(&pm_cur_left, &pm_cur_right);
|
|
#ifdef HAVE_RECORDING
|
|
else
|
|
pcm_calculate_rec_peaks(&pm_cur_left, &pm_cur_right);
|
|
#endif
|
|
left = pm_cur_left;
|
|
right = pm_cur_right;
|
|
#else
|
|
#ifndef SIMULATOR
|
|
pm_cur_left = left = mas_codec_readreg(pm_src_left);
|
|
pm_cur_right = right = mas_codec_readreg(pm_src_right);
|
|
#else
|
|
pm_cur_left = left = 8000;
|
|
pm_cur_right = right = 9000;
|
|
#endif
|
|
#endif
|
|
|
|
/* check for clips
|
|
An clip is assumed when two consecutive readouts
|
|
of the volume are at full scale. This is proven
|
|
to be inaccurate in both ways: it may detect clips
|
|
when no clip occurred and it may fail to detect
|
|
a real clip. For software codecs, the peak is already
|
|
the max of a bunch of samples, so use one max value
|
|
or you fail to detect clipping! */
|
|
#if CONFIG_CODEC == SWCODEC
|
|
if (left == MAX_PEAK - 1) {
|
|
#else
|
|
if ((left == pm_max_left) &&
|
|
(left == MAX_PEAK - 1)) {
|
|
#endif
|
|
pm_clip_left = true;
|
|
pm_clip_timeout_l =
|
|
current_tick + clip_time_out[pm_clip_hold];
|
|
}
|
|
|
|
#if CONFIG_CODEC == SWCODEC
|
|
if (right == MAX_PEAK - 1) {
|
|
#else
|
|
if ((right == pm_max_right) &&
|
|
(right == MAX_PEAK - 1)) {
|
|
#endif
|
|
pm_clip_right = true;
|
|
pm_clip_timeout_r =
|
|
current_tick + clip_time_out[pm_clip_hold];
|
|
}
|
|
|
|
#ifdef HAVE_RECORDING
|
|
if(!was_clipping && (pm_clip_left || pm_clip_right))
|
|
{
|
|
if(pm_clipcount_active)
|
|
pm_clipcount++;
|
|
}
|
|
#endif
|
|
|
|
/* peaks are searched -> we have to find the maximum. When
|
|
many calls of peak_meter_peek the maximum value will be
|
|
stored in pm_max_xxx. This maximum is reset by the
|
|
functions peak_meter_read_x. */
|
|
pm_max_left = MAX(pm_max_left, left);
|
|
pm_max_right = MAX(pm_max_right, right);
|
|
|
|
#ifdef HAVE_RECORDING
|
|
#if CONFIG_CODEC == SWCODEC
|
|
/* Ignore any unread peakmeter data */
|
|
#define MAX_DROP_TIME HZ/7 /* this value may need tweaking. Increase if you are
|
|
getting trig events when you shouldn't with
|
|
trig_stp_hold = 0 */
|
|
if (!trig_stp_hold)
|
|
trig_stp_hold = MAX_DROP_TIME;
|
|
#endif
|
|
|
|
switch (trig_status) {
|
|
case TRIG_READY:
|
|
/* no more changes, if trigger was activated as release trigger */
|
|
/* threshold exceeded? */
|
|
if ((left > trig_strt_threshold)
|
|
|| (right > trig_strt_threshold)) {
|
|
/* reset trigger duration */
|
|
trig_hightime = current_tick;
|
|
|
|
/* reset dropout duration */
|
|
trig_lowtime = current_tick;
|
|
|
|
if (trig_strt_duration)
|
|
set_trig_status(TRIG_STEADY);
|
|
else
|
|
/* if trig_duration is set to 0 the user wants to start
|
|
recording immediately */
|
|
set_trig_status(TRIG_GO);
|
|
}
|
|
break;
|
|
|
|
case TRIG_STEADY:
|
|
case TRIG_RETRIG:
|
|
/* trigger duration exceeded */
|
|
if (current_tick - trig_hightime > trig_strt_duration) {
|
|
set_trig_status(TRIG_GO);
|
|
} else {
|
|
/* threshold exceeded? */
|
|
if ((left > trig_strt_threshold)
|
|
|| (right > trig_strt_threshold)) {
|
|
/* reset lowtime */
|
|
trig_lowtime = current_tick;
|
|
}
|
|
/* volume is below threshold */
|
|
else {
|
|
/* dropout occurred? */
|
|
if (current_tick - trig_lowtime > trig_strt_dropout){
|
|
if (trig_status == TRIG_STEADY){
|
|
set_trig_status(TRIG_READY);
|
|
}
|
|
/* trig_status == TRIG_RETRIG */
|
|
else {
|
|
/* the gap has already expired */
|
|
trig_lowtime = current_tick - trig_rstrt_gap - 1;
|
|
set_trig_status(TRIG_POSTREC);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
break;
|
|
|
|
case TRIG_GO:
|
|
case TRIG_CONTINUE:
|
|
/* threshold exceeded? */
|
|
if ((left > trig_stp_threshold)
|
|
|| (right > trig_stp_threshold)) {
|
|
/* restart hold time countdown */
|
|
trig_lowtime = current_tick;
|
|
#if CONFIG_CODEC == SWCODEC
|
|
} else if (current_tick - trig_lowtime > MAX_DROP_TIME){
|
|
#else
|
|
} else {
|
|
#endif
|
|
set_trig_status(TRIG_POSTREC);
|
|
trig_hightime = current_tick;
|
|
}
|
|
break;
|
|
|
|
case TRIG_POSTREC:
|
|
/* gap time expired? */
|
|
if (current_tick - trig_lowtime > trig_rstrt_gap){
|
|
/* start threshold exceeded? */
|
|
if ((left > trig_strt_threshold)
|
|
|| (right > trig_strt_threshold)) {
|
|
|
|
set_trig_status(TRIG_RETRIG);
|
|
trig_hightime = current_tick;
|
|
trig_lowtime = current_tick;
|
|
}
|
|
else
|
|
|
|
/* stop threshold exceeded */
|
|
if ((left > trig_stp_threshold)
|
|
|| (right > trig_stp_threshold)) {
|
|
if (current_tick - trig_hightime > trig_stp_hold){
|
|
trig_lowtime = current_tick;
|
|
set_trig_status(TRIG_CONTINUE);
|
|
} else {
|
|
trig_lowtime = current_tick - trig_rstrt_gap - 1;
|
|
}
|
|
}
|
|
|
|
/* below any threshold */
|
|
else {
|
|
if (current_tick - trig_lowtime > trig_stp_hold){
|
|
set_trig_status(TRIG_READY);
|
|
} else {
|
|
trig_hightime = current_tick;
|
|
}
|
|
}
|
|
}
|
|
|
|
/* still within the gap time */
|
|
else {
|
|
/* stop threshold exceeded */
|
|
if ((left > trig_stp_threshold)
|
|
|| (right > trig_stp_threshold)) {
|
|
set_trig_status(TRIG_CONTINUE);
|
|
trig_lowtime = current_tick;
|
|
}
|
|
|
|
/* hold time expired */
|
|
else if (current_tick - trig_lowtime > trig_stp_hold){
|
|
trig_hightime = current_tick;
|
|
trig_lowtime = current_tick;
|
|
set_trig_status(TRIG_READY);
|
|
}
|
|
}
|
|
break;
|
|
}
|
|
#if CONFIG_CODEC == SWCODEC
|
|
/* restore stop hold value */
|
|
if (trig_stp_hold == MAX_DROP_TIME)
|
|
trig_stp_hold = 0;
|
|
#endif
|
|
#endif
|
|
/* check levels next time peakmeter drawn */
|
|
level_check = true;
|
|
#ifdef PM_DEBUG
|
|
peek_calls++;
|
|
#endif
|
|
}
|
|
|
|
/**
|
|
* Reads out the peak volume of the left channel.
|
|
* @return int - The maximum value that has been detected
|
|
* since the last call of peak_meter_read_l. The value
|
|
* is in the range 0 <= value < MAX_PEAK.
|
|
*/
|
|
static int peak_meter_read_l(void)
|
|
{
|
|
/* pm_max_left contains the maximum of all peak values that were read
|
|
by peak_meter_peek since the last call of peak_meter_read_l */
|
|
int retval;
|
|
|
|
#if defined(SIMULATOR) && (CONFIG_CODEC != SWCODEC)
|
|
srand(current_tick);
|
|
pm_max_left = rand()%MAX_PEAK;
|
|
#endif
|
|
|
|
retval = pm_max_left;
|
|
|
|
#if defined(HAVE_RECORDING_HISTOGRAM) || defined(HAVE_AGC)
|
|
/* store max peak value for peak_meter_get_peakhold_x readout */
|
|
pm_peakhold_left = MAX(pm_max_left, pm_peakhold_left);
|
|
#endif
|
|
#ifdef PM_DEBUG
|
|
peek_calls = 0;
|
|
#endif
|
|
/* reset pm_max_left so that subsequent calls of peak_meter_peek don't
|
|
get fooled by an old maximum value */
|
|
pm_max_left = pm_cur_left;
|
|
|
|
return retval;
|
|
}
|
|
|
|
/**
|
|
* Reads out the peak volume of the right channel.
|
|
* @return int - The maximum value that has been detected
|
|
* since the last call of peak_meter_read_l. The value
|
|
* is in the range 0 <= value < MAX_PEAK.
|
|
*/
|
|
static int peak_meter_read_r(void)
|
|
{
|
|
/* peak_meter_r contains the maximum of all peak values that were read
|
|
by peak_meter_peek since the last call of peak_meter_read_r */
|
|
int retval;
|
|
|
|
#if defined(SIMULATOR) && (CONFIG_CODEC != SWCODEC)
|
|
srand(current_tick);
|
|
pm_max_right = rand()%MAX_PEAK;
|
|
#endif
|
|
|
|
retval = pm_max_right;
|
|
|
|
#if defined(HAVE_RECORDING_HISTOGRAM) || defined(HAVE_AGC)
|
|
/* store max peak value for peak_meter_get_peakhold_x readout */
|
|
pm_peakhold_right = MAX(pm_max_right, pm_peakhold_right);
|
|
#endif
|
|
#ifdef PM_DEBUG
|
|
peek_calls = 0;
|
|
#endif
|
|
/* reset pm_max_right so that subsequent calls of peak_meter_peek don't
|
|
get fooled by an old maximum value */
|
|
pm_max_right = pm_cur_right;
|
|
|
|
return retval;
|
|
}
|
|
|
|
#if defined(HAVE_AGC) || defined(HAVE_RECORDING_HISTOGRAM)
|
|
/**
|
|
* Reads out the current peak-hold values since the last call.
|
|
* This is used by the histogram feature in the recording screen.
|
|
* Values are in the range 0 <= peak_x < MAX_PEAK. MAX_PEAK is typ 32767.
|
|
*/
|
|
void peak_meter_get_peakhold(int *peak_left, int *peak_right)
|
|
{
|
|
if (peak_left)
|
|
*peak_left = pm_peakhold_left;
|
|
if (peak_right)
|
|
*peak_right = pm_peakhold_right;
|
|
pm_peakhold_left = 0;
|
|
pm_peakhold_right = 0;
|
|
}
|
|
#endif
|
|
|
|
/**
|
|
* Reset the detected clips. This method is for
|
|
* use by the user interface.
|
|
* @param int unused - This parameter was added to
|
|
* make the function compatible with set_int
|
|
*/
|
|
void peak_meter_set_clip_hold(int time)
|
|
{
|
|
pm_clip_left = false;
|
|
pm_clip_right = false;
|
|
pm_clip_eternal = (time > 0) ? false : true;
|
|
}
|
|
|
|
/**
|
|
* Scales a peak value as read from the MAS to the range of meterwidth.
|
|
* The scaling is performed according to the scaling method (dBfs / linear)
|
|
* and the range (peak_meter_range_min .. peak_meter_range_max).
|
|
* @param unsigned short val - The volume value. Range: 0 <= val < MAX_PEAK
|
|
* @param int meterwidht - The widht of the meter in pixel
|
|
* @return unsigned short - A value 0 <= return value <= meterwidth
|
|
*/
|
|
unsigned short peak_meter_scale_value(unsigned short val, int meterwidth)
|
|
{
|
|
int retval;
|
|
|
|
if (val <= peak_meter_range_min) {
|
|
return 0;
|
|
}
|
|
|
|
if (val >= peak_meter_range_max) {
|
|
return meterwidth;
|
|
}
|
|
|
|
retval = val;
|
|
|
|
/* different scaling is used for dBfs and linear percent */
|
|
if (pm_use_dbfs) {
|
|
|
|
/* scale the samples dBfs */
|
|
retval = (calc_db(retval) - pm_db_min) * meterwidth / pm_db_range;
|
|
}
|
|
|
|
/* Scale for linear percent display */
|
|
else
|
|
{
|
|
/* scale the samples */
|
|
retval = ((retval - peak_meter_range_min) * meterwidth)
|
|
/ pm_range;
|
|
}
|
|
return retval;
|
|
}
|
|
void peak_meter_screen(struct screen *display, int x, int y, int height)
|
|
{
|
|
peak_meter_draw(display, &scales[display->screen_type], x, y,
|
|
display->getwidth() - x, height);
|
|
}
|
|
/**
|
|
* Draws a peak meter in the specified size at the specified position.
|
|
* @param int x - The x coordinate.
|
|
* Make sure that 0 <= x and x + width < display->getwidth()
|
|
* @param int y - The y coordinate.
|
|
* Make sure that 0 <= y and y + height < display->getheight()
|
|
* @param int width - The width of the peak meter. Note that for display
|
|
* of clips a 3 pixel wide area is used ->
|
|
* width > 3
|
|
* @param int height - The height of the peak meter. height > 3
|
|
*/
|
|
static void peak_meter_draw(struct screen *display, struct meter_scales *scales,
|
|
int x, int y, int width, int height)
|
|
{
|
|
static int left_level = 0, right_level = 0;
|
|
int left = 0, right = 0;
|
|
int meterwidth = width - 3;
|
|
int i, delta;
|
|
#if defined(HAVE_REMOTE_LCD) && !defined (ROCKBOX_HAS_LOGF)
|
|
static long peak_release_tick[2] = {0,0};
|
|
int screen_nr = display->screen_type == SCREEN_MAIN ? 0 : 1;
|
|
#else
|
|
static long peak_release_tick = 0;
|
|
#endif
|
|
|
|
#ifdef PM_DEBUG
|
|
static long pm_tick = 0;
|
|
int tmp = peek_calls;
|
|
#endif
|
|
|
|
/* if disabled only draw the peak meter */
|
|
if (peak_meter_enabled) {
|
|
|
|
|
|
if (level_check){
|
|
/* only read the volume info from MAS if peek since last read*/
|
|
left_level = peak_meter_read_l();
|
|
right_level = peak_meter_read_r();
|
|
level_check = false;
|
|
}
|
|
|
|
/* scale the samples dBfs */
|
|
left = peak_meter_scale_value(left_level, meterwidth);
|
|
right = peak_meter_scale_value(right_level, meterwidth);
|
|
|
|
/*if the scale has changed -> recalculate the scale
|
|
(The scale becomes invalid when the range changed.) */
|
|
if (!scales->db_scale_valid){
|
|
|
|
if (pm_use_dbfs) {
|
|
db_scale_count = DB_SCALE_SRC_VALUES_SIZE;
|
|
for (i = 0; i < db_scale_count; i++){
|
|
/* find the real x-coords for predefined interesting
|
|
dBfs values. These only are recalculated when the
|
|
scaling of the meter changed. */
|
|
scales->db_scale_lcd_coord[i] =
|
|
peak_meter_scale_value(
|
|
db_scale_src_values[i],
|
|
meterwidth - 1);
|
|
}
|
|
}
|
|
|
|
/* when scaling linear we simly make 10% steps */
|
|
else {
|
|
db_scale_count = 10;
|
|
for (i = 0; i < db_scale_count; i++) {
|
|
scales->db_scale_lcd_coord[i] =
|
|
(i * (MAX_PEAK / 10) - peak_meter_range_min) *
|
|
meterwidth / pm_range;
|
|
}
|
|
}
|
|
|
|
/* mark scale valid to avoid recalculating dBfs values
|
|
of the scale. */
|
|
scales->db_scale_valid = true;
|
|
}
|
|
|
|
/* apply release */
|
|
#if defined(HAVE_REMOTE_LCD) && !defined (ROCKBOX_HAS_LOGF)
|
|
delta = current_tick - peak_release_tick[screen_nr];
|
|
peak_release_tick[screen_nr] = current_tick;
|
|
#else
|
|
delta = current_tick - peak_release_tick;
|
|
peak_release_tick = current_tick;
|
|
#endif
|
|
left = MAX(left , scales->last_left - delta * pm_peak_release);
|
|
right = MAX(right, scales->last_right - delta * pm_peak_release);
|
|
|
|
/* reset max values after timeout */
|
|
if (TIME_AFTER(current_tick, scales->pm_peak_timeout_l)){
|
|
scales->pm_peak_left = 0;
|
|
}
|
|
|
|
if (TIME_AFTER(current_tick, scales->pm_peak_timeout_r)){
|
|
scales->pm_peak_right = 0;
|
|
}
|
|
|
|
if (!pm_clip_eternal) {
|
|
if (pm_clip_left &&
|
|
TIME_AFTER(current_tick, pm_clip_timeout_l)){
|
|
pm_clip_left = false;
|
|
}
|
|
|
|
if (pm_clip_right &&
|
|
TIME_AFTER(current_tick, pm_clip_timeout_r)){
|
|
pm_clip_right = false;
|
|
}
|
|
}
|
|
|
|
/* check for new max values */
|
|
if (left > scales->pm_peak_left) {
|
|
scales->pm_peak_left = left - 1;
|
|
scales->pm_peak_timeout_l =
|
|
current_tick + peak_time_out[pm_peak_hold];
|
|
}
|
|
|
|
if (right > scales->pm_peak_right) {
|
|
scales->pm_peak_right = right - 1;
|
|
scales->pm_peak_timeout_r =
|
|
current_tick + peak_time_out[pm_peak_hold];
|
|
}
|
|
}
|
|
|
|
/* draw the peak meter */
|
|
display->set_drawmode(DRMODE_SOLID|DRMODE_INVERSEVID);
|
|
display->fillrect(x, y, width, height);
|
|
display->set_drawmode(DRMODE_SOLID);
|
|
|
|
/* draw left */
|
|
display->fillrect (x, y, left, height / 2 - 2 );
|
|
if (scales->pm_peak_left > 0) {
|
|
display->vline(x + scales->pm_peak_left, y, y + height / 2 - 2 );
|
|
}
|
|
if (pm_clip_left) {
|
|
display->fillrect(x + meterwidth, y, 3, height / 2 - 1);
|
|
}
|
|
|
|
/* draw right */
|
|
display->fillrect(x, y + height / 2 + 1, right, height / 2 - 2);
|
|
if (scales->pm_peak_right > 0) {
|
|
display->vline( x + scales->pm_peak_right, y + height / 2, y + height - 2);
|
|
}
|
|
if (pm_clip_right) {
|
|
display->fillrect(x + meterwidth, y + height / 2, 3, height / 2 - 1);
|
|
}
|
|
|
|
/* draw scale end */
|
|
display->vline(x + meterwidth, y, y + height - 2);
|
|
|
|
/* draw dots for scale marks */
|
|
for (i = 0; i < db_scale_count; i++) {
|
|
/* The x-coordinates of interesting scale mark points
|
|
have been calculated before */
|
|
display->drawpixel(x + scales->db_scale_lcd_coord[i],
|
|
y + height / 2 - 1);
|
|
}
|
|
|
|
#ifdef HAVE_RECORDING
|
|
|
|
#ifdef HAVE_BACKLIGHT
|
|
/* cliplight */
|
|
if ((pm_clip_left || pm_clip_right) &&
|
|
global_settings.cliplight &&
|
|
#if CONFIG_CODEC == SWCODEC
|
|
!pm_playback)
|
|
#else
|
|
!(audio_status() & (AUDIO_STATUS_PLAY | AUDIO_STATUS_ERROR)))
|
|
#endif
|
|
{
|
|
/* if clipping, cliplight setting on and in recording screen */
|
|
if (global_settings.cliplight <= 2)
|
|
{
|
|
/* turn on main unit light if setting set to main or both*/
|
|
backlight_on();
|
|
}
|
|
#ifdef HAVE_REMOTE_LCD
|
|
if (global_settings.cliplight >= 2)
|
|
{
|
|
/* turn remote light unit on if setting set to remote or both */
|
|
remote_backlight_on();
|
|
}
|
|
#endif /* HAVE_REMOTE_LCD */
|
|
}
|
|
#endif /* HAVE_BACKLIGHT */
|
|
|
|
if (trig_status != TRIG_OFF) {
|
|
int start_trigx, stop_trigx, ycenter;
|
|
|
|
display->set_drawmode(DRMODE_SOLID);
|
|
ycenter = y + height / 2;
|
|
/* display threshold value */
|
|
start_trigx = x+peak_meter_scale_value(trig_strt_threshold,meterwidth);
|
|
display->vline(start_trigx, ycenter - 2, ycenter);
|
|
start_trigx ++;
|
|
if (start_trigx < display->getwidth() ) display->drawpixel(start_trigx,
|
|
ycenter - 1);
|
|
|
|
stop_trigx = x + peak_meter_scale_value(trig_stp_threshold,meterwidth);
|
|
display->vline(stop_trigx, ycenter - 2, ycenter);
|
|
if (stop_trigx > 0) display->drawpixel(stop_trigx - 1, ycenter - 1);
|
|
}
|
|
#endif /*HAVE_RECORDING*/
|
|
|
|
#ifdef PM_DEBUG
|
|
/* display a bar to show how many calls to peak_meter_peek
|
|
have ocurred since the last display */
|
|
display->set_drawmode(DRMODE_COMPLEMENT);
|
|
display->fillrect(x, y, tmp, 3);
|
|
|
|
if (tmp < PEEKS_PER_DRAW_SIZE) {
|
|
peeks_per_redraw[tmp]++;
|
|
}
|
|
|
|
tmp = current_tick - pm_tick;
|
|
if (tmp < TICKS_PER_DRAW_SIZE ){
|
|
ticks_per_redraw[tmp] ++;
|
|
}
|
|
|
|
/* display a bar to show how many ticks have passed since
|
|
the last redraw */
|
|
display->fillrect(x, y + height / 2, current_tick - pm_tick, 2);
|
|
pm_tick = current_tick;
|
|
#endif
|
|
|
|
scales->last_left = left;
|
|
scales->last_right = right;
|
|
|
|
display->set_drawmode(DRMODE_SOLID);
|
|
}
|
|
|
|
#ifdef HAVE_RECORDING
|
|
/**
|
|
* Defines the parameters of the trigger. After these parameters are defined
|
|
* the trigger can be started either by peak_meter_attack_trigger or by
|
|
* peak_meter_release_trigger. Note that you can pass either linear (%) or
|
|
* logarithmic (db) values to the thresholds. Positive values are intepreted as
|
|
* percent (0 is 0% .. 100 is 100%). Negative values are interpreted as db.
|
|
* To avoid ambiguosity of the value 0 the negative values are shifted by -1.
|
|
* Thus -75 is -74db .. -1 is 0db.
|
|
* @param start_threshold - The threshold used for attack trigger. Negative
|
|
* values are interpreted as db -1, positive as %.
|
|
* @param start_duration - The minimum time span within which start_threshold
|
|
* must be exceeded to fire the attack trigger.
|
|
* @param start_dropout - The maximum time span the level may fall below
|
|
* start_threshold without releasing the attack trigger.
|
|
* @param stop_threshold - The threshold the volume must fall below to release
|
|
* the release trigger.Negative values are
|
|
* interpreted as db -1, positive as %.
|
|
* @param stop_hold - The minimum time the volume must fall below the
|
|
* stop_threshold to release the trigger.
|
|
* @param
|
|
*/
|
|
void peak_meter_define_trigger(
|
|
int start_threshold,
|
|
long start_duration,
|
|
long start_dropout,
|
|
int stop_threshold,
|
|
long stop_hold_time,
|
|
long restart_gap
|
|
)
|
|
{
|
|
if (start_threshold < 0) {
|
|
/* db */
|
|
if (start_threshold < -89) {
|
|
trig_strt_threshold = 0;
|
|
} else {
|
|
trig_strt_threshold =peak_meter_db2sample((start_threshold+1)*100);
|
|
}
|
|
} else {
|
|
/* linear percent */
|
|
trig_strt_threshold = start_threshold * MAX_PEAK / 100;
|
|
}
|
|
trig_strt_duration = start_duration;
|
|
trig_strt_dropout = start_dropout;
|
|
if (stop_threshold < 0) {
|
|
/* db */
|
|
trig_stp_threshold = peak_meter_db2sample((stop_threshold + 1) * 100);
|
|
} else {
|
|
/* linear percent */
|
|
trig_stp_threshold = stop_threshold * MAX_PEAK / 100;
|
|
}
|
|
trig_stp_hold = stop_hold_time;
|
|
trig_rstrt_gap = restart_gap;
|
|
}
|
|
|
|
/**
|
|
* Enables or disables the trigger.
|
|
* @param on - If true the trigger is turned on.
|
|
*/
|
|
void peak_meter_trigger(bool on)
|
|
{
|
|
/* don't use set_trigger here as that would fire an undesired event */
|
|
trig_status = on ? TRIG_READY : TRIG_OFF;
|
|
}
|
|
|
|
/**
|
|
* Registers the listener function that listenes on trig_status changes.
|
|
* @param listener - The function that is called with each change of
|
|
* trig_status. May be set to NULL if no callback is desired.
|
|
*/
|
|
void peak_meter_set_trigger_listener(void (*listener)(int status))
|
|
{
|
|
trigger_listener = listener;
|
|
}
|
|
|
|
/**
|
|
* Fetches the status of the trigger.
|
|
* TRIG_OFF: the trigger is inactive
|
|
* TRIG_RELEASED: The volume level is below the threshold
|
|
* TRIG_ACTIVATED: The volume level has exceeded the threshold, but the trigger
|
|
* hasn't been fired yet.
|
|
* TRIG_FIRED: The volume exceeds the threshold
|
|
*
|
|
* To activate the trigger call either peak_meter_attack_trigger or
|
|
* peak_meter_release_trigger. To turn the trigger off call
|
|
* peak_meter_trigger_off.
|
|
*/
|
|
int peak_meter_trigger_status(void)
|
|
{
|
|
return trig_status; /* & TRIG_PIT_MASK;*/
|
|
}
|
|
|
|
void peak_meter_draw_trig(int xpos[], int ypos[],
|
|
int trig_width[], int nb_screens)
|
|
{
|
|
int barstart[NB_SCREENS];
|
|
int barend[NB_SCREENS];
|
|
int icon;
|
|
int ixpos[NB_SCREENS];
|
|
int i;
|
|
int trigbar_width[NB_SCREENS];
|
|
|
|
FOR_NB_SCREENS(i)
|
|
trigbar_width[i] = (trig_width[i] - (2 * (ICON_PLAY_STATE_WIDTH + 1)));
|
|
|
|
switch (trig_status) {
|
|
|
|
case TRIG_READY:
|
|
FOR_NB_SCREENS(i){
|
|
barstart[i] = 0;
|
|
barend[i] = 0;
|
|
}
|
|
icon = Icon_Stop;
|
|
FOR_NB_SCREENS(i)
|
|
ixpos[i] = xpos[i];
|
|
break;
|
|
|
|
case TRIG_STEADY:
|
|
case TRIG_RETRIG:
|
|
FOR_NB_SCREENS(i)
|
|
{
|
|
barstart[i] = 0;
|
|
barend[i] = (trig_strt_duration == 0) ? trigbar_width[i] :
|
|
trigbar_width[i] *
|
|
(current_tick - trig_hightime) / trig_strt_duration;
|
|
}
|
|
icon = Icon_Stop;
|
|
FOR_NB_SCREENS(i)
|
|
ixpos[i] = xpos[i];
|
|
break;
|
|
|
|
case TRIG_GO:
|
|
case TRIG_CONTINUE:
|
|
FOR_NB_SCREENS(i)
|
|
{
|
|
barstart[i] = trigbar_width[i];
|
|
barend[i] = trigbar_width[i];
|
|
}
|
|
icon = Icon_Record;
|
|
FOR_NB_SCREENS(i)
|
|
ixpos[i] = xpos[i]+ trig_width[i] - ICON_PLAY_STATE_WIDTH;
|
|
break;
|
|
|
|
case TRIG_POSTREC:
|
|
FOR_NB_SCREENS(i)
|
|
{
|
|
barstart[i] = (trig_stp_hold == 0) ? 0 :
|
|
trigbar_width[i] - trigbar_width[i] *
|
|
(current_tick - trig_lowtime) / trig_stp_hold;
|
|
barend[i] = trigbar_width[i];
|
|
}
|
|
icon = Icon_Record;
|
|
FOR_NB_SCREENS(i)
|
|
ixpos[i] = xpos[i] + trig_width[i] - ICON_PLAY_STATE_WIDTH;
|
|
break;
|
|
|
|
default:
|
|
return;
|
|
}
|
|
|
|
for(i = 0; i < nb_screens; i++)
|
|
{
|
|
gui_scrollbar_draw(&screens[i], xpos[i] + ICON_PLAY_STATE_WIDTH + 1,
|
|
ypos[i] + 1, trigbar_width[i], TRIG_HEIGHT - 2,
|
|
trigbar_width[i], barstart[i], barend[i],
|
|
HORIZONTAL);
|
|
|
|
screens[i].mono_bitmap(bitmap_icons_7x8[icon], ixpos[i], ypos[i],
|
|
ICON_PLAY_STATE_WIDTH, STATUSBAR_HEIGHT);
|
|
}
|
|
}
|
|
#endif
|
|
|
|
int peak_meter_draw_get_btn(int action_context, int x[], int y[],
|
|
int height[], int nb_screens,
|
|
struct viewport vps[])
|
|
{
|
|
int button = BUTTON_NONE;
|
|
long next_refresh = current_tick;
|
|
long next_big_refresh = current_tick + HZ / 10;
|
|
int i;
|
|
#if (CONFIG_CODEC == SWCODEC)
|
|
bool highperf = false;
|
|
#else
|
|
/* On MAS targets, we need to poll as often as possible in order to not
|
|
* miss a peak, as the MAS does only provide a quasi-peak. When the disk
|
|
* is active, it must not draw too much CPU power or a buffer overrun can
|
|
* happen when saving a recording. As a compromise, poll only once per tick
|
|
* when the disk is active, otherwise spin around as fast as possible. */
|
|
bool highperf = !storage_disk_is_active();
|
|
#endif
|
|
bool dopeek = true;
|
|
|
|
while (TIME_BEFORE(current_tick, next_big_refresh)) {
|
|
button = get_action(action_context, TIMEOUT_NOBLOCK);
|
|
if (button != BUTTON_NONE) {
|
|
break;
|
|
}
|
|
if (dopeek) { /* Peek only once per refresh when disk is */
|
|
peak_meter_peek(); /* spinning, but as often as possible */
|
|
dopeek = highperf; /* otherwise. */
|
|
yield();
|
|
} else {
|
|
sleep(0); /* Sleep until end of current tick. */
|
|
}
|
|
if (TIME_AFTER(current_tick, next_refresh)) {
|
|
for(i = 0; i < nb_screens; i++)
|
|
{
|
|
screens[i].set_viewport(&vps[i]);
|
|
peak_meter_screen(&screens[i], x[i], y[i], height[i]);
|
|
screens[i].update_viewport_rect(x[i], y[i],
|
|
screens[i].getwidth() - x[i],
|
|
height[i]);
|
|
}
|
|
next_refresh += HZ / PEAK_METER_FPS;
|
|
dopeek = true;
|
|
}
|
|
}
|
|
|
|
return button;
|
|
}
|
|
|
|
#ifdef PM_DEBUG
|
|
static void peak_meter_clear_histogram(void)
|
|
{
|
|
int i = 0;
|
|
for (i = 0; i < TICKS_PER_DRAW_SIZE; i++) {
|
|
ticks_per_redraw[i] = (unsigned int)0;
|
|
}
|
|
|
|
for (i = 0; i < PEEKS_PER_DRAW_SIZE; i++) {
|
|
peeks_per_redraw[i] = (unsigned int)0;
|
|
}
|
|
}
|
|
|
|
bool peak_meter_histogram(void)
|
|
{
|
|
int i;
|
|
int btn = BUTTON_NONE;
|
|
while ((btn & BUTTON_OFF) != BUTTON_OFF )
|
|
{
|
|
unsigned int max = 0;
|
|
int y = 0;
|
|
int x = 0;
|
|
screens[0].clear_display();
|
|
|
|
for (i = 0; i < PEEKS_PER_DRAW_SIZE; i++) {
|
|
max = MAX(max, peeks_per_redraw[i]);
|
|
}
|
|
|
|
for (i = 0; i < PEEKS_PER_DRAW_SIZE; i++) {
|
|
x = peeks_per_redraw[i] * (LCD_WIDTH - 1)/ max;
|
|
screens[0].hline(0, x, y + i);
|
|
}
|
|
|
|
y = PEEKS_PER_DRAW_SIZE + 1;
|
|
max = 0;
|
|
|
|
for (i = 0; i < TICKS_PER_DRAW_SIZE; i++) {
|
|
max = MAX(max, ticks_per_redraw[i]);
|
|
}
|
|
|
|
for (i = 0; i < TICKS_PER_DRAW_SIZE; i++) {
|
|
x = ticks_per_redraw[i] * (LCD_WIDTH - 1)/ max;
|
|
screens[0].hline(0, x, y + i);
|
|
}
|
|
screens[0].update();
|
|
|
|
btn = button_get(true);
|
|
if (btn == BUTTON_PLAY) {
|
|
peak_meter_clear_histogram();
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
#endif
|
|
|
|
|