eq.c

ESS3890+SL原代码（1*16内存）

        sign_ft = FONT_EQ_MINUS;
        level = 11-level;
    }
    EQ_db_line[0] = sign_ft;
    EQ_db_line[1] = EQ_level2dbfont[level];
    ICON_charset_select(VWENGLISH_FONTS);
    ICON_set_bkcolor(0);
    CG_map_color_array(EQ_DB_TEXT_COLOR, 15, 3);
    x = 366+initx_pixel;
    y = 32+inity_pixel; 
    OSD_area_fill(x, y, x+24, y+32, 0);

    strcpy(osdmsg, EQ_db_line+(!level)); 
    CGI_text_show(osdmsg, 16+EQ_box_initx, 1+EQ_box_inity, -1, -1);

    ICON_charset_restore();
}


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


    if (turn_on) {
	if (osd_eq_mode != OSD_KSC_SPECTRUM) {
	    CG_set_scr(CG_EQPLAY_MODE); /* calls OSD_clear() */

	    /* char position */
	    EQ_box_initx = EQ_DISP_INIT_X;
	    EQ_box_inity = EQ_DISP_INIT_Y;
	    /* pixel position */
	    initx_pixel = EQ_DISP_INIT_X; 
	    inity_pixel = EQ_DISP_INIT_Y; 
	} 
#ifdef KARASC
	else {
	    CG_set_scr(CG_KSC_MODE); /* calls OSD_clear() */
	    
	    /* char position */
	    EQ_box_initx = MIC_SPECTRUM_X;
	    EQ_box_inity = MIC_SPECTRUM_Y;
	    
	    /* pixel position */
	    initx_pixel = MIC_SPECTRUM_X;
	    inity_pixel = MIC_SPECTRUM_Y;
	}
#endif KARASC
	cg_ch2pixel(&initx_pixel, &inity_pixel); 
    } else {
        /* Remove EQ display and put back previous OSD settings */
        if (EQ_refresh_cnt) {
	    EQ_refresh_cnt = 0;
            ICON_charset_restore();
	}

        OSD_eq_mode = 0;
	CG_set_scr(CG_FULL_SCR); /* calls OSD_clear() */
	ICON_set_bkcolor(0);
#ifdef DATA_CD
        if ((STREAM_type == MP3_ID) || (STREAM_type == WMA_ID) ||
	    ((STREAM_type == JPEG_ID) && (play_state == ENTRY_STATE))) {
            mp3_menu_changed = 1;
            MP3_select();
        } 
#endif
    }
    GI_msg_reset(0);
}

void EQ_display(char mode)
{
    uchar *p, osdmsg[CG_LINE_WIDTH+1];
    int i, j;


    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, OSD_eq_mode);
    } else if (mode == OSD_EQ_CONTROL) { /* show bare panel */
	for (j=0; j < 3; j++)
	    for (i=EQ_60HZ; i <= EQ_15KHZ; i++)
		EQ_lines[j][i] = FONT_EQ_LEV0;
	for (i=EQ_60HZ; i <= EQ_15KHZ; i++)
	    EQ_lines[3][i] = 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) {
	spectrum_data[0].data = eq_volume;
#ifdef KARASC
	/* just initialize it..prevent random address writes */
	spectrum_data[1].data = mic_eq_volume;
#endif
	EQ_disp_spectrum();

        EQ_refresh_cnt = 3; 
	EQ_refresh_state = EQ_UPDATE_BACKGROUND;
	eq_timer = glbTimer+QUARTER_SECOND;
    } 
#ifdef KARASC
    else if (mode == OSD_KSC_SPECTRUM) {
	spectrum_data[0].data = eq_volume;
	spectrum_data[1].data = mic_eq_volume;
        EQ_prep_spectrum(1);

        EQ_refresh_cnt = 3; 
	EQ_refresh_state = EQ_UPDATE_BACKGROUND;
	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, x, y;
    uchar osdmsg[CG_LINE_WIDTH+1];
    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) {
    	    ICON_charset_select(VWENGLISH_FONTS);
    	    CG_map_color_array(EQ_BACK_FRAME_COLOR, EQ_FREQ_NORMAL_COLOR, 3);
#ifdef KARASC
	    /* char position */
	    initx_pixel = EQ_box_initx = EQ_DISP_INIT_X;
	    inity_pixel = EQ_box_inity = EQ_DISP_INIT_Y;

	    if (OSD_eq_mode == OSD_KSC_SPECTRUM) {
		music_or_mic ^= 1;
		if (music_or_mic) {
		    /* char position */
		    initx_pixel = EQ_box_initx = MIC_SPECTRUM_X;
		    inity_pixel = EQ_box_inity = MIC_SPECTRUM_Y;
		} 
#ifdef SBS_KARA
		else {
		    /* "spin" disc..ICON_ADISC1 or ICON_ADISC2 */
		    i = ICON_ADISC1+((glbTimer&0x10)>>4);
		    if (i != EQ_disc_icon) {
			EQ_disc_icon = i;
			ICON_set_bkcolor(0);
			initx_pixel = MUSIC_SPECTRUM_X;
			inity_pixel = MUSIC_SPECTRUM_Y+3;
			cg_ch2pixel(&initx_pixel, &inity_pixel); 
			GI_icon_show(i, initx_pixel, inity_pixel);
		    }
		    
		    /* char position */
		    initx_pixel = EQ_box_initx = MUSIC_SPECTRUM_X;
		    inity_pixel = EQ_box_inity = MUSIC_SPECTRUM_Y;
		}
#endif SBS_KARA
	    }
	    
	    cg_ch2pixel(&initx_pixel, &inity_pixel); /* pixel position */
#endif KARASC
    	    ICON_set_bkcolor(EQ_BACK_GROUND_COLOR);
            EQ_set_spectrum(music_or_mic);
            eq_show_volume = music_or_mic+1; /* 1 or 2 */
            eq_refresh_cal(music_or_mic);
        }
        EQ_refresh_cnt = eq_refresh_disp(EQ_refresh_cnt, music_or_mic);
        if (!EQ_refresh_cnt) {
            ICON_charset_restore();
	    /* 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 */
	    ICON_charset_select(VWENGLISH_FONTS);
	    i = (EQ_refresh_cnt-4)*2;
	    EQ_adj(i, eq_settings[(i>>1)]);
	    ICON_charset_restore();
	} else if (EQ_refresh_cnt<12) {
	    /* music type..uses fixed size fonts! */
 	    x = initx_pixel;
	    y = 32*4+inity_pixel;
	    /* clear old message(20 chars) */
	    OSD_area_fill(x, y, x+160, y+30, 0); 
	    strcpy(osdmsg, OSD_eqfx_msg[EQ_music_type_effect]);
	    CGI_text_show(osdmsg, EQ_box_initx, EQ_box_inity+4, -1, -1);
 	} 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;
	}
	EQ_refresh_cnt++;
	eq_timer = glbTimer + FIFTEENTH_SECOND;

	break;

    case EQ_UPDATE_BACKGROUND:
	ICON_charset_select(VWENGLISH_FONTS);
        ICON_set_bkcolor(EQ_BACK_GROUND_COLOR);
	CG_map_color_array(EQ_BACK_FRAME_COLOR, EQ_FREQ_NORMAL_COLOR, 3);
        i=EQ_refresh_cnt-1;
	strcpy(osdmsg, EQ_lines[i]); 
        CGI_text_show(osdmsg, EQ_box_initx, EQ_box_inity+i, -1, -1);

	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_state = EQ_UPDATE_SPECTRUM;
	    }
#ifdef KARASC
	} else if (OSD_eq_mode == OSD_KSC_SPECTRUM) {
	    /* Spectrum..from bottom to top */
	    EQ_refresh_cnt--;	    
	    if (!EQ_refresh_cnt) {
		if (music_or_mic != 0xf) {
		    /* use fixed size fonts! */
		    ICON_charset_restore();
		    strcpy(osdmsg, MSG_mic);
                    CG_map_color_array(1,6,3);
		    CGI_text_show(osdmsg, EQ_box_initx, EQ_box_inity+3,-1,-1);

		    /* Set to display "music" background */
		    music_or_mic = 0xf;
		    EQ_refresh_cnt = 3;	    
#ifdef SBS_KARA
		    EQ_box_initx = MUSIC_SPECTRUM_X;
		    EQ_box_inity = MUSIC_SPECTRUM_Y;
#else
		    EQ_box_initx = EQ_DISP_INIT_X;
		    EQ_box_inity = EQ_DISP_INIT_Y;
#endif SBS_KARA
		} else {
		    /* Show disc icon */
		    ICON_set_bkcolor(0);
		    initx_pixel = EQ_box_initx;
		    inity_pixel = EQ_box_inity+3;
		    cg_ch2pixel(&initx_pixel, &inity_pixel); 
		    GI_icon_show(ICON_ADISC1, initx_pixel, inity_pixel);
		    ICON_charset_restore();

		    music_or_mic = 0;
		    EQ_refresh_state = EQ_UPDATE_SPECTRUM;
		}
	    }
#endif KARASC
	} 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 PLAY20
#ifdef JPEG_DEC
	    && (STREAM_type != JPEG_ID)
#endif
	    && (play_state == PLAY_NORMAL_STATE)
#endif /* PLAY20 */
	    ) {
	    EQ_display_setup(1, OSD_eq_mode_previous);
	    
	    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 */
#ifdef SBS_KARA
#define REF_LOOP_LIMIT(x) sbs_limit[x]
#else
#define REF_LOOP_LIMIT(x) REFRESH_LOOP_MAX_TIMES
#endif
int eq_refresh_disp(int loop, int spectrum_index)
{
    int i, j, k, x, y, max_y, max_j, count=0;
    SPECTRUM *sp_ptr;
#ifdef SBS_KARA
    int sbs_factor, sbs_limit[]={0,REFRESH_LOOP_MAX_TIMES,28};

    sbs_factor = (OSD_eq_mode == OSD_KSC_SPECTRUM) ? 2 : 1;
#else
#define sbs_factor 1
#endif


    sp_ptr = &(spectrum_data[spectrum_index]);
    do {
	j = loop&0x3;
    	i = (loop>>2)*sbs_factor;
	if (j < 3) {
            k = EQ_lines[j][i];
            if (k) {
		count++;
                eq_pixel_mapping(i/sbs_factor, j, &x, &y);
		ICON_color_mapping(2, freq_bar_color[j]);  
                GI_icon_show(k, x, inity_pixel+32*j);
            }
	} else {
            eq_pixel_mapping(i/sbs_factor, sp_ptr->sp_max_shadow[i], 
			     &x, &max_y);
            eq_pixel_mapping(i/sbs_factor, sp_ptr->sp_max[i], &x, &y);
            max_j = eq_block_mapping(sp_ptr->sp_max_shadow[i]); 
	    k = EQ_lines[max_j][i];
	    if (y == max_y) {
            	if (k) OSD_area_fill(x+2, y, x+22, y+2, EQ_FREQ_MAX_COLOR);
	    } else if (k) {
            	OSD_area_fill(x+2, y, x+22, y+2, EQ_FREQ_MAX_COLOR);
	    } else {
	    	OSD_area_fill(x+2, max_y, x+22, max_y+2, EQ_BACK_GROUND_COLOR);
		OSD_dot(x+11, max_y, EQ_BACK_FRAME_COLOR);
	        OSD_dot(x+12, max_y, EQ_BACK_FRAME_COLOR);   
                OSD_dot(x+11, max_y+1, EQ_BACK_FRAME_COLOR);   
                OSD_dot(x+12, max_y+1, EQ_BACK_FRAME_COLOR);   	
		OSD_area_fill(x+2, y, x+22, y+2, EQ_FREQ_MAX_COLOR);
	    }
	    sp_ptr->sp_max_shadow[i] = y; 
        }

	if (++loop >= REF_LOOP_LIMIT(sbs_factor))
	    return 0;
    } while (count<REFRESH_CHAR_MAX_NUMBER);
    return loop;
}

/* step-by-step update of EQ controls display */
void eq_refresh_cal(int spectrum_index)
{
    int i, j, x, y, level, y1, level1, max, max1;
    SPECTRUM *sp_ptr;

    sp_ptr = &(spectrum_data[spectrum_index]);
    for (i=EQ_60HZ; i <= EQ_15KHZ; i++) {
        level = sp_ptr->sp[i];
        level1 = sp_ptr->sp_shadow[i];
        if (level == level1) {
            EQ_lines[0][i] = EQ_lines[1][i] = EQ_lines[2][i] = 0;
        } else {
            y=eq_block_mapping(level);
            y1=eq_block_mapping(level1);
            if (y == y1) {
                for (j=0; j<3; j++) {
                    if (j == y)
                        EQ_lines[y][i] = EQ_spectrum2font[level&0x7];
                    else
                        EQ_lines[j][i] = 0;
                }
            } else if (y1 < y) {
                for (j=0; j<3; j++) {
                    if (j < y1 || j > y)
                        EQ_lines[j][i] = 0;
                    else if (j < y)
                        EQ_lines[j][i] = FONT_EQ_LEV0;
                    else if (j == y)
                        EQ_lines[y][i] = EQ_spectrum2font[level&0x7];
                    else
                        assert(0);
                }
            } else {
                for (j=0; j<3; j++) {
                    if (j < y || j > y1)
                        EQ_lines[j][i] = 0;
                    else if (j == y)
                        EQ_lines[y][i] = EQ_spectrum2font[level&0x7];
                    else if (j <= y1)
                        EQ_lines[j][i] = FONT_EQ_S8;
                    else
                        assert(0);
                } 
            }
        }
    }  
}
#endif EQUALIZER