lc_eq.c

来自「ESS3890+SL原代码（1*16内存）」· C语言 代码 · 共 487 行

/* Copyright 2003, ESS Technology, Inc. */
/* SCCSID @(#)lc_eq.c	4.2 10/17/03 */

/* Based on eq.c	1.14 02/17/03 */

/*
 * $Log$  
 */
#ifdef EQUALIZER

#include "vcxi.h"
#include "const.h"
#include "memmap.h"
#include "display.h"
#include "util.h"
#include "xport.h"
#include "fsosd.h"
#include "timedef.h"
#include "dsa.h"
#include "filesys.h"
#include "panel.h"
#include "eq.h"
#include "play.h"

#ifdef MP3
#include "mp3.h"
#endif

#if 0
int bpt;
#define BREAKPOINT(x) {bpt=x;while(bpt) VCX_service();}
#else
#define BREAKPOINT(x)
#endif

/************************************************************************
 * Local OSD definitions						*
 ************************************************************************/
#define EPRINTF(a) 
#define assert(a)

#define REFRESH_RATE			THIRTIETH_SECOND
#define REFRESH_CHAR_MAX_NUMBER		3
#define REFRESH_LOOP_MAX_TIMES		52
#define EQ_DISP_BRING_BACK_TIME		(3*ONE_SECOND)

/************************************************************************
 * Local variables 
 ************************************************************************/
static uint eq_timer;
static unsigned char *eq_settings;
#ifdef KARASC
static SPECTRUM spectrum_data[2]; /* vocal & mic */
#else
static SPECTRUM spectrum_data[1];
#endif KARASC

/************************************************************************
 * Global variables declared in this module				*
 ************************************************************************/
/* Begin EQ variables */

char EQ_levels[13] = {
    EQ_LEVEL_ZERO,EQ_LEVEL_ZERO,EQ_LEVEL_ZERO,EQ_LEVEL_ZERO,EQ_LEVEL_ZERO,
    EQ_LEVEL_ZERO,EQ_LEVEL_ZERO,EQ_LEVEL_ZERO,EQ_LEVEL_ZERO,EQ_LEVEL_ZERO,
    EQ_LEVEL_ZERO,EQ_LEVEL_ZERO,EQ_LEVEL_ZERO
};

static uchar EQ_lines[4][14];

#ifdef NO_BILINGUAL_OSD /* enable after we have the required Chinese fonts */ 
#define TOTAL_EQFX_MSG	(2*TOTAL_EQFX)
#else
#define TOTAL_EQFX_MSG	TOTAL_EQFX
#endif
unsigned char *OSD_eqfx_msg[TOTAL_EQFX_MSG] = {
#ifdef MORE_ENV_TYPES
    "GAME", "NIGHT", "MORNING", "PARTY",
#endif
    "STUDIO", "STADIUM", "CLUB", "MOVIE", "CHURCH", "HALL", "STANDARD",
    "CLASSIC", "JAZZ", "ROCK", "POPS", "BALLAD", "DANCE", "PERSONAL",
};


/* End EQ variables..begin EQ functions */

int eq_block_mapping(int freq_level);
void EQ_set_spectrum(int);
void EQ_prep_spectrum(void);
int eq_refresh_disp(int, int);
static void eq_adj(int, int);

void eq_pixel_mapping(int freq, int freq_level, int *x, int *y)
{
    /* get pixel coordinate */
    *x = (49 + (freq<<4) + (freq<<3)); /*48 + 24*freq + 1*/
    *y = ((23 - freq_level)<<1); /* (23-level)*2 */
}

int eq_block_mapping(int freq_level)
{
    if (freq_level > EQ_LEVEL_POS12) return (-1);
    return (2 - (freq_level >> 3));
}

void EQ_set_spectrum(int spectrum_index)
{
    int i, sp_level, spmax_level;
    SPECTRUM *sp_ptr;
   

#ifdef KARASC
    if (spectrum_index == 1) EQ_volume_interp();
#endif KARASC
    
    sp_ptr = &(spectrum_data[spectrum_index]);

    for (i = EQ_60HZ; i <= EQ_15KHZ; i++) {
	sp_ptr->sp_shadow[i] = sp_ptr->sp[i];
	sp_ptr->sp_max_shadow[i] = sp_ptr->sp_max[i];
        if ((i & 0x1) == 0) {
            sp_level = sp_ptr->data[i>>1];
        } else {
            sp_level += sp_ptr->data[(i+1)>>1];
            sp_level >>= 1;
        }
        if (sp_level < 0) sp_level = 0;
        sp_ptr->sp[i] = sp_level;
        spmax_level = sp_ptr->sp_max[i];
        /* new spectrum max */
        sp_ptr->sp_max[i] = (sp_level >= spmax_level) ?
            sp_level : (spmax_level - 1);
    }
}


void EQ_prep_spectrum(void)
{
    int i;
    SPECTRUM *sp_ptr1;
#ifdef KARASC
    SPECTRUM *sp_ptr2;
#endif
    
    sp_ptr1 = &(spectrum_data[0]);
#ifdef KARASC
    sp_ptr2 = &(spectrum_data[1]);
#endif

    for (i=EQ_60HZ; i <= EQ_15KHZ; i++) {
	sp_ptr1->sp[i] = EQ_LEVEL_NEG12;
#ifdef KARASC
	sp_ptr2->sp[i] = EQ_LEVEL_NEG12;
#endif
	EQ_lines[0][i] = FONT_SPACE; 
	EQ_lines[1][i] = FONT_SPACE; 
	EQ_lines[2][i] = FONT_SPACE; 
        /* Freq indicator level font */
        EQ_lines[3][i] = T_EQ_minus12_font[i];
    }
}

void EQ_adj(int freq, int freq_level)
{
    /* update for eq processing */
    eq_level[freq>>1] = freq_level--; /* -1-23 -> 0-24 */
    eq_change_gain = 1;
    eq_adj(freq, freq_level);

    if (freq != EQ_15KHZ) {
	freq_level = (int)((EQ_levels[freq] + EQ_levels[freq+2]) >> 1);
        eq_adj((freq + 1), freq_level);
    }
    if (freq != EQ_60HZ) {
	freq_level = (int)((EQ_levels[freq] + EQ_levels[freq-2]) >> 1);
        eq_adj((freq - 1), freq_level);
    }
}

static void eq_adj(int freq, int freq_level)
{
    int x, y, level, font;
    unsigned int color;

    /* clear current level indicator */
    level = (int)EQ_levels[freq];
    x = freq;
    y = eq_block_mapping(level);
    font = (level == EQ_LEVEL_NEG12) ? 
    T_EQ_minus12_font[freq] : FONT_EQ_LEV0; /* "clear" font */
    color = 0xaaaa;
    if (freq == EQ_cur_freq) color = 0xffff;
    if (y != 3) OSD_put_one_char(x+2, 3, T_EQ_minus12_font[freq]);
    OSD_put_one_char(x+2, y, font);
	
    /* get pixel coordinate and paint new level */
    eq_pixel_mapping(freq, freq_level, &x, &y);    
    OSD_paint_rect(x, y, 22, 1, color);
    EQ_levels[freq] = freq_level; /* update */
}

void EQ_show_db(int freq)
{
    int level;
    uchar EQ_db_line[4] = {FONT_EQ_PLUS, FONT_EQ_DB0, FONT_EQ_DB, 0};

    level = EQ_levels[freq] - 11;
    if (level <= 0) {
        level = -level;
        EQ_db_line[0] = (level) ? FONT_EQ_MINUS : FONT_SPACE;
    }
    EQ_db_line[1] = T_EQ_level2dbfont[level];
    OUTOSD(6, EQ_db_line, EQ_db_line, 0);
}


void EQ_display_setup(char turn_on, int dummy)
{
    extern int mp3_menu_changed;

    CLEARALLOSD();
    OSD_dram_dy = OSD_DRAM_DY;
    OSD_ntsc_vert_pos1 = OSD_NTSC_VERT_POS1;
    OSD_pal_vert_pos1 = OSD_PAL_VERT_POS1;
    if (turn_on) {
        int tmp = (OSD_CHAR_HEIGHT << 1) - 1;
        OSD_total_areas = 1;
	/* Set up OSD positions/dimensions */
	OSD_cfgline (OSD_LINE_1, OSD_AREA_1, 2, 11, 15);
	OSD_cfgline (OSD_LINE_2, OSD_AREA_1, 2, 11, 15);
	OSD_cfgline (OSD_LINE_3, OSD_AREA_1, 2, 11, 15);
	OSD_cfgline (OSD_LINE_4, OSD_AREA_1, 2, 11, 15);

	OSD_ntsc_vert_end1 = OSD_NTSC_VERT_POS1 + tmp;
	OSD_pal_vert_end1 = OSD_PAL_VERT_POS1 + tmp;
    } else {
        /* Remove EQ display and put back previous OSD settings */
        if (EQ_refresh_cnt) {
	    EQ_refresh_cnt = 0;
	}
        OSD_eq_mode = 0;
        OSD_init();
        OSD_dram_dx = OSD_DRAM_DX;

        OSD_total_areas = OSD_TOTAL_AREAS;
	OSD_ntsc_vert_end1 = OSD_NTSC_VERT_END1;
	OSD_pal_vert_end1 = OSD_PAL_VERT_END1;
#if (defined(MP3) || defined(GAMEBOY))
        if (STREAM_type == MP3_ID) {
	    OSD_dram_dy = ((OSD_LINES_IN_AREA_1*OSD_CHAR_HEIGHT) >> 1);
            mp3_menu_changed=1;
	}
#endif
    }
    OSD_set_vstart_end(vcx_scn_height);
}

void EQ_display(char mode)
{
    int i;
    uchar *msg, *c_msg;

    if (!mode) {
	/* set timer to bring back EQ later */
	eq_timer = (OSD_eq_mode_previous) 
	    ? glbTimer+EQ_DISP_BRING_BACK_TIME 
	    : xINFINITY; /* ..a long, long time */
	
	EQ_refresh_state = EQ_UPDATE_IDLE;

	/* Remove EQ display and put back previous OSD settings */
	EQ_display_setup(0, 0);
    } else if (mode == OSD_EQ_CONTROL) { /* show bare panel */
	for (i=EQ_60HZ; i <= EQ_15KHZ; i++) {
	    EQ_lines[0][i] = FONT_EQ_LEV0;
	    EQ_lines[1][i] = FONT_EQ_LEV0;
	    EQ_lines[2][i] = FONT_EQ_LEV0;
	    EQ_lines[3][i] = T_EQ_minus12_font[i];
	}

	eq_settings = (EQ_music_type_effect == EQFX_PERSONAL) ? 
	    eq_person_level : &(EQ_SETTINGS[EQ_music_type_effect*7]);

	EQ_refresh_cnt = 1;
	EQ_refresh_state = EQ_UPDATE_BACKGROUND;
	eq_timer = glbTimer;
    } else if (mode == OSD_EQ_SPECTRUM) {
	/* load some custom colors for spectrum*/
	OSD_load_palette(0x3241); 
	/* adjust OSD width..so that spectrum sits in the center */
	OSD_dram_dx = 18*OSD_CHAR_WIDTH/16;

	spectrum_data[0].data = eq_volume;
#ifdef KARASC
	/* just initialize it..prevent random address writes */
	spectrum_data[1].data = eq_volume; 
#endif 
	EQ_prep_spectrum();
	/* only display "frequency" line (bottom) here */
	OUTOSD(10, EQ_lines[3], EQ_lines[3], 0);

        EQ_refresh_cnt = 3; 
	EQ_refresh_state = EQ_UPDATE_BACKGROUND;
	eq_timer = glbTimer+QUARTER_SECOND;
    } 
#ifdef KARASC
    else if (mode == OSD_KSC_SPECTRUM) {
	/* load some custom colors for spectrum*/
	OSD_load_palette(0x3241); 
	/* adjust OSD width to fit side-by-side spectrum */
	OSD_dram_dx = OSD_DRAM_DX;

	spectrum_data[0].data = eq_volume;
	spectrum_data[1].data = mic_eq_volume;
        EQ_prep_spectrum();

	/* Set to display "mic" background */
	assign_osd_msg(msg, MSG_mic, c_msg, MSG_mic);
	OUTOSD(10, msg, c_msg, 0);

	/* Set to display "music" background */
	assign_osd_msg(msg, MSG_music, c_msg, MSG_music);
	OUTOSD(11, msg, c_msg, 0);
	
	EQ_refresh_cnt = 1; /* for initial refresh */
	EQ_refresh_state = EQ_UPDATE_SPECTRUM;
	eq_timer = glbTimer+QUARTER_SECOND;
    }
#endif KARASC
}

/* 
 * Function: Equalizer OSD display update state-machine
 * 
 * input:
 *	EQ_refresh_state(global) - state of EQ_refresh().
 *	EQ_refresh_cnt(global) - the intermediate states of EQ_refresh().
 *
 * output:		      
 *	EQ_refresh_cnt(global) - the intermediate states of EQ_refresh().
 *		when value is zero, indicates non-EQ OSD processes are allowed.
 */
int EQ_refresh(void)
{
    int i;
    uchar *msg, *c_msg;
    static uchar music_or_mic;

    if (eq_timer > glbTimer) return (EQ_refresh_cnt);
    
    switch (EQ_refresh_state) {
    case EQ_UPDATE_SPECTRUM:
	if (!EQ_refresh_cnt) {
#ifdef KARASC
	    music_or_mic ^= (OSD_eq_mode == OSD_KSC_SPECTRUM);
#endif KARASC

            EQ_set_spectrum(music_or_mic);
            eq_show_volume = music_or_mic+1; /* 1 or 2 */
        }
        EQ_refresh_cnt = eq_refresh_disp(EQ_refresh_cnt, music_or_mic);
        if (!EQ_refresh_cnt) {
	    /* double refresh rate for KSC spectrum */
            eq_timer = glbTimer+REFRESH_RATE-(OSD_eq_mode == OSD_KSC_SPECTRUM);
        }
	break;

    case EQ_UPDATE_LEVELS:
	if (EQ_refresh_cnt < 11) { /* current gain level and data note */
	    i = (EQ_refresh_cnt << 1) - 8;
	    EQ_adj(i, eq_settings[(i>>1)]);
	    EQ_refresh_cnt++;
    	    eq_timer = glbTimer + FIFTEENTH_SECOND;
            break;
 	} else {
	    EQ_show_db(EQ_cur_freq);
	    EQ_refresh_state = EQ_UPDATE_IDLE;
	    EQ_refresh_cnt = 0;
	    eq_timer = xINFINITY; /* ..a long, long time */
	    break;
	}

    case EQ_UPDATE_BACKGROUND:
        i = EQ_refresh_cnt - 1;

	assign_osd_msg(msg, EQ_lines[i], c_msg, EQ_lines[i]);
	OUTOSD(3*i+1, msg, c_msg, 0);

	if (OSD_eq_mode == OSD_EQ_SPECTRUM) {
	    /* Spectrum..from bottom to top */
	    EQ_refresh_cnt--;	    
	    if (!EQ_refresh_cnt) {
		music_or_mic = 0;
		EQ_refresh_cnt = 1; /* for initial refresh */
		EQ_refresh_state = EQ_UPDATE_SPECTRUM;
	    }
	} else {
	    /* EQ settings..from top to bottom */
	    EQ_refresh_cnt++;	    
	    if (EQ_refresh_cnt>3) EQ_refresh_state = EQ_UPDATE_LEVELS;
	}
	eq_timer = glbTimer+FIFTEENTH_SECOND;

	break;

    case EQ_UPDATE_IDLE:
	/* Check if we need to bring back EQ OSD */
	if (EQ_mode && OSD_eq_mode_previous && !OSD_eq_mode &&
#ifdef PLAYONLY
	    XPORT_active
#else
	    (play_state == PLAY_NORMAL_STATE)
#endif
	    ) {
	    EQ_display_setup(1, 0);
	    
	    OSD_eq_mode = OSD_eq_mode_previous;
	    OSD_eq_mode_previous = 0;
	    EQ_display(OSD_eq_mode);
	}
	break;	

    default:
	EQ_refresh_cnt = 0;
	eq_timer = xINFINITY; /* ..a long, long time */
	break;
    }

    return (EQ_refresh_cnt);
}


/* refresh spectrum display */
int eq_refresh_disp(int loop, int spectrum_index)
{
    static char freq;
    int i, x, y, max_y, max_j, count=1;
    int factor, eq_box_offset;
    SPECTRUM *sp_ptr;

    loop++;
#ifdef KARASC
    factor = (OSD_eq_mode == OSD_KSC_SPECTRUM) ? 2 : 1;
    /* eq_box_offset: 
     *		0 - for standalone spectrum and mic spectrum (side-by-side)
     *		9 - music spectrum (side-by-side)
     */
    eq_box_offset = ((factor+spectrum_index)&1) ? 0 : 9;
#else
    factor = 1;
    eq_box_offset = 0;
#endif
    
    sp_ptr = &(spectrum_data[spectrum_index]);
    for (i=freq; i <= EQ_15KHZ; i+=factor, freq+=factor, count++) {
	int k = (sp_ptr->sp[i] - sp_ptr->sp_shadow[i]) | 
	    (sp_ptr->sp_max[i] - sp_ptr->sp_max_shadow[i]);	
	if (k) { /* update as needed */
            int i_factor = (factor == 1) ? i : (i >> 1);
	    /* spectrum levels */
	    eq_pixel_mapping(eq_box_offset + i_factor, sp_ptr->sp[i], &x, &max_y);
	    eq_pixel_mapping(eq_box_offset + i_factor, sp_ptr->sp_shadow[i], 
			     &x, &y);
	    OSD_paint_spectrum(x, max_y, y, sp_ptr->sp[i], 
			       sp_ptr->sp_shadow[i]);
	
	    /* spectrum max levels */
	    eq_pixel_mapping(eq_box_offset + i_factor, sp_ptr->sp_max_shadow[i], 
			     &x, &max_j);
	    eq_pixel_mapping(eq_box_offset + i_factor, sp_ptr->sp_max[i], 
			     &x, &y);
	    if (y > max_j) {
		OSD_paint_rect(x, max_j, 22, 1, 0); /* black */
		OSD_paint_rect(x, y, 22, 1, 0xffff); /* white */
	    } else if ((y < max_j) || (y == max_y)) {
		OSD_paint_rect(x, y, 22, 1, 0xffff); /* white */
	    }
	}
	
	if (count>=REFRESH_CHAR_MAX_NUMBER) return (loop);
    }
    freq = 0;
    return 0;
}

#endif EQUALIZER