/***************************************************************************
 *             __________               __   ___.
 *   Open      \______   \ ____   ____ |  | _\_ |__   _______  ___
 *   Source     |       _//  _ \_/ ___\|  |/ /| __ \ /  _ \  \/  /
 *   Jukebox    |    |   (  <_> )  \___|    < | \_\ (  <_> > <  <
 *   Firmware   |____|_  /\____/ \___  >__|_ \|___  /\____/__/\_ \
 *                     \/            \/     \/    \/            \/
 * $Id: $
 *
 * Copyright (C) 2002 by Philipp Pertermann
 *
 * All files in this archive are subject to the GNU General Public License.
 * See the file COPYING in the source tree root for full license agreement.
 *
 * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY
 * KIND, either express or implied.
 *
 ****************************************************************************/
#include "mas.h"
#include "thread.h"
#include "kernel.h"
#include "settings.h"
#include "lcd.h"
#include "wps-display.h"
#include "menu.h"
#include "sprintf.h"
#include "button.h"
#include "system.h"
#include "font.h"
#include "icons.h"
#include "lang.h"

static char peak_meter_name[] = { "Peak Meter" } ;
static char peak_meter_stack[DEFAULT_STACK_SIZE / 2];

#ifdef HAVE_LCD_BITMAP
static int peak_meter_max_l;
static int peak_meter_max_r;
static long peak_meter_timeout_l;
static long peak_meter_timeout_r;
static long peak_meter_overflow_timeout_l;
static long peak_meter_overflow_timeout_r;
#endif

bool peak_meter_enabled = false;
static int peak_meter_l;
static int peak_meter_r;
static bool peak_meter_l_overflow = false;
static bool peak_meter_r_overflow = false;

/**
 * This is the main loop of the peak meter thread. It reads volume levels 
 * from the mas and finds maxima. These maxima are stored for later display.
 * To reduce cpu / i²c bus load (e.g. when no peak meter is displayed) 
 * this loop can be turned off by setting the variable peak_meter_enabled. 
 */
static void peak_meter_thread(void)
{
    /* somehow rockbox freezes while booting if
       we don't wait for a while */
    sleep(500);
    while (1) {
       /* if the peak meter is disabled we don't want
          to communicate with the mas in order to save
          energy */
       if (peak_meter_enabled)
       {
           /* read the peak values */
            int left = mas_codec_readreg(0xC);
            int right = mas_codec_readreg(0xD);

            /* check for overflows
               An overflow 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 overflows
               when no overflow occurred and it may fail to detect
               a real overflow. */

            if ((left  == peak_meter_l) && 
                (left  == MAX_PEAK - 1)) {
                peak_meter_l_overflow = true;
                peak_meter_overflow_timeout_l = 
                    current_tick + global_settings.peak_meter_overflow * HZ;
            }

            if ((right == peak_meter_r) && 
                (right == MAX_PEAK - 1)) {
                peak_meter_r_overflow = true;
                peak_meter_overflow_timeout_r = 
                    current_tick + global_settings.peak_meter_overflow * HZ;
            }

            /* peaks are searched -> we have to find the maximum */
            peak_meter_l = MAX(peak_meter_l, left);
            peak_meter_r = MAX(peak_meter_r, right);
       }
        yield();
    }
}

/**
 * Installs the peak meter thread 
 */
void peak_meter_init(void) 
{
    create_thread(peak_meter_thread, peak_meter_stack,
                  sizeof(peak_meter_stack), peak_meter_name);
}

/**
 * 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) {
    int retval = peak_meter_l;
    peak_meter_l = mas_codec_readreg(0xC);
    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) {
    int retval = peak_meter_r;
    peak_meter_r = mas_codec_readreg(0xD);
    return retval;
}

/**
 * Reset the detected overflows. 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_reset_overflow(int unused) {
    peak_meter_l_overflow = false;
    peak_meter_r_overflow = false;
}

#ifdef HAVE_LCD_BITMAP
/**
 * 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 < LCD_WIDTH
 * @param int y - The y coordinate. 
 *                Make sure that 0 <= y and y + height < LCD_HEIGHT
 * @param int width - The width of the peak meter. Note that for display
 *                    of overflows a 3 pixel wide area is used ->
 *                    width > 3
 * @param int height - The height of the peak meter. height > 3
 */
void peak_meter_draw(int x, int y, int width, int height) {
    int left, right;
    int meterwidth = width - 3;
    int i;

    /* read the volume info from MAS */
    left  = peak_meter_read_l() / (MAX_PEAK / meterwidth);
    right = peak_meter_read_r() / (MAX_PEAK / meterwidth);

    /* reset max values after timeout */
    if (TIME_AFTER(current_tick, peak_meter_timeout_l)){
        peak_meter_max_l = 0;
    }

    if (TIME_AFTER(current_tick, peak_meter_timeout_r)){
        peak_meter_max_r = 0;
    }

    if (peak_meter_l_overflow && TIME_AFTER(current_tick, peak_meter_overflow_timeout_l)){
        peak_meter_l_overflow = false;
    }

    if (peak_meter_r_overflow && TIME_AFTER(current_tick, peak_meter_overflow_timeout_r)){
        peak_meter_r_overflow = false;
    }

    /* check for new max values */
    if (left > peak_meter_max_l) {
        peak_meter_max_l = left - 1;
        peak_meter_timeout_l = 
            current_tick + global_settings.peak_meter_release;
    }

    if (right > peak_meter_max_r) {
        peak_meter_max_r = right - 1;
        peak_meter_timeout_r = 
            current_tick + global_settings.peak_meter_release;
    }

    /* draw the peak meter */
    lcd_clearrect(x, y, width, height);

    /* draw left */
    lcd_fillrect (x, y, left, height / 2 -1 );
    if (peak_meter_max_l > 0) {
        lcd_drawline(x + peak_meter_max_l, y, 
                     x + peak_meter_max_l, y + height / 2 -2 );
    }
    if (peak_meter_l_overflow) {
        lcd_fillrect(x + meterwidth, y, 3, height / 2 - 1);
    }

    /* draw right */
    lcd_fillrect(x, y + height / 2, right, height / 2- 1);
    if (peak_meter_max_r > 0) {
        lcd_drawline( x + peak_meter_max_r, y + height / 2, 
                      x + peak_meter_max_r, y + height);
    }
    if (peak_meter_r_overflow) {
        lcd_fillrect(x + meterwidth, y + height / 2, 3, height / 2 - 1);
    }

    /* draw scale */
    lcd_drawline(x, y + height / 2 - 1, 
                 x + width - 1, y + height / 2 - 1);
    lcd_drawline(x + meterwidth, y,
                 x + meterwidth, y + height);
    for (i = 0; i < 10; i++) {
        lcd_invertpixel(x + meterwidth * i / 10, y + height / 2 - 1);
    }
}
#endif