panelvfd.c

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

    else {
	show_panel_time(0);
	VFD_blank(VFD_TRACK);
	VFD_icon(VFDICON_hyphen_off);
    }    
}

/*===========================================================================*/
void panel_total_track(int total_track_num)
{
    VFD_icon(VFDICON_track);
    VFD_icon((total_track_num > MAX_CALENDAR) ? 
	     VFDICON_more_on : VFDICON_more_off);
    
    /* 
     * Clear the message field. Some VFD's have gaps (such at 100 min)
     * that will otherwise not be cleared by anybody!
     */
    VFD_msg(VFDMSG_clearall);
    VFD_segment(VFD_TRACK, total_track_num, 1);
    VFD_calendar(0);
}

/*===========================================================================*/
/* only program calls this function                                          */
void panel_track_select(int track_num, int flag)
{
    int tmp;

    if (flag <= 0) { /* invalid track: flag = -1 */
	show_program_osd_number(TOTAL_PROGRAM_TRACKS + 1, track_num, 
				(flag) ? 1 : 0);
    } else {
	VFD_calendar(0);	
	VFD_segment(VFD_TRACK, TOTAL_PROGRAM_TRACKS, 1);
	showProgramTime(-1);
	
	show_program_osd_number(TOTAL_PROGRAM_TRACKS, track_num, 1);
    }
}

/*===========================================================================*/
void panel_track_deselected(int track_num)
{
    VFD_calendar(0);
    VFD_segment(VFD_TRACK, TOTAL_PROGRAM_TRACKS, 1);
    showProgramTime(-1);
    
    /* update OSD */
    show_program_osd_number(TOTAL_PROGRAM_TRACKS, 
			    (TOTAL_PROGRAM_TRACKS) ? 
			    track_list[TOTAL_PROGRAM_TRACKS - 1] : 0, 1);
}

/*===========================================================================*/
void panel_repeat_ab(int mode)
{
    int timeout;
    unsigned char *msg_ptr;
#ifdef BILINGUAL_OSD
    unsigned char *c_msg_ptr;
#endif

    timeout = 0; /* Leave message on */

    if (mode == REPEAT_AB_OFF) {
#ifdef MIC_RECORD
        if (REC_status == REC_REPEAT_STATE) return;
#endif
	assign_osd_msg(msg_ptr, MSG_clearA2B, c_msg_ptr, MSG_c_clearA2B);
	timeout = QUICK_TIME_OUT; /* Clear msg after 1sec */

	if (repeat_mode == REPEAT_OFF) VFD_icon(VFDICON_repeat_off);
	VFD_icon(VFDICON_clear_ab);
    } else if (mode == REPEAT_AB_START) {
	VFD_icon(VFDICON_seta);
	assign_osd_msg(msg_ptr, MSG_set_A, c_msg_ptr, MSG_c_set_A);
    } else { /* (mode == REPEAT_AB_END) */
	VFD_icon(VFDICON_setb);
	assign_osd_msg(msg_ptr, MSG_repeatA2B, c_msg_ptr, MSG_c_repeatA2B);
    }

    OUTOSD(OSD_INPUT_MODE_REGION, msg_ptr, c_msg_ptr, timeout);
}

/*===========================================================================*/
#define GOTO_MIN_POS    7
#define GOTO_SEC_POS    (GOTO_MIN_POS + 3)
#ifdef USE_CN_HEADER
#define CGOTO_MIN_POS    7
#else
#define CGOTO_MIN_POS    5
#endif /* USE_CN_HEADER */
#define CGOTO_SEC_POS    (CGOTO_MIN_POS + 3)
void panel_goto(int mode, int value)
{
    int timeout = 0;
    unsigned char *msg_ptr;
#ifdef BILINGUAL_OSD
    unsigned char *c_msg_ptr;
#endif

    assign_osd_msg(msg_ptr, goto_buf, c_msg_ptr, c_goto_buf);
    value += '0';

    if (mode == GOTO_OFF) {
        msg_ptr[GOTO_MIN_POS] = 'X';
        msg_ptr[GOTO_MIN_POS+1] = 'X';
        msg_ptr[GOTO_SEC_POS] = 'X';
        msg_ptr[GOTO_SEC_POS+1] = 'X';
#ifdef BILINGUAL_OSD
        c_msg_ptr[CGOTO_MIN_POS] = 'X';
        c_msg_ptr[CGOTO_MIN_POS+1] = 'X';
        c_msg_ptr[CGOTO_SEC_POS] = 'X';
        c_msg_ptr[CGOTO_SEC_POS+1] = 'X';
#endif
	timeout = DISPLAY_TIME_OUT;
    } else if (mode == GOTO_START) {
        msg_ptr[GOTO_MIN_POS] = '_';
        msg_ptr[GOTO_MIN_POS+1] = '_';
        msg_ptr[GOTO_SEC_POS] = '_';
        msg_ptr[GOTO_SEC_POS+1] = '_';
#ifdef BILINGUAL_OSD
        c_msg_ptr[CGOTO_MIN_POS] = '_';
        c_msg_ptr[CGOTO_MIN_POS+1] = '_';
        c_msg_ptr[CGOTO_SEC_POS] = '_';
        c_msg_ptr[CGOTO_SEC_POS+1] = '_';
#endif
    } else if (mode == GOTO_MINUTE_TEN) {
        msg_ptr[GOTO_MIN_POS] = value;
#ifdef BILINGUAL_OSD
        c_msg_ptr[CGOTO_MIN_POS] = value;
#endif
    } else if (mode == GOTO_MINUTE) {
        msg_ptr[GOTO_MIN_POS+1] = value;
#ifdef BILINGUAL_OSD
        c_msg_ptr[CGOTO_MIN_POS+1] = value;
#endif
    } else if (mode == GOTO_SECOND_TEN) {
        msg_ptr[GOTO_SEC_POS] = value;
#ifdef BILINGUAL_OSD
        c_msg_ptr[CGOTO_SEC_POS] = value;
#endif
    } else if (mode == GOTO_SECOND) {
        msg_ptr[GOTO_SEC_POS+1] = value;
#ifdef BILINGUAL_OSD
        c_msg_ptr[CGOTO_SEC_POS+1] = value;
#endif
	timeout = EXTENDED_TIME_OUT;
    }
    
    OUTOSD(OSD_GOTO_REGION, msg_ptr, c_msg_ptr, timeout);
}

static void show_panel_time(int time)
{
    unsigned int temp_servo_info;
    int bcdsec, bcdmin;
    

    /* If there is a wheel, then spin it! */
    if (T_VFD_wheel_SZ) VFD_spin_wheel(VFD_WHEEL_SPIN);

    bcdmin = (time >> 16) & 0xff;
    bcdsec = (time >>  8) & 0xff;

    VFD_icon(VFDICON_colon_on);
    VFD_segment(VFD_MINUTE, bcdmin, 1);
    VFD_segment(VFD_SECOND, bcdsec, 0);

    /* since we will not get new servo_info in stop mode, we fake a new
       servo_info and call osd update routine. */
    if ((DiscMode & DISC_OSD_ON) && 
	(SystemStatus == SYSTEM_STOP)) {
	temp_servo_info = servo_info; /* save real servo info */
	servo_info = (bcdmin << 8) | bcdsec;
	OSD_time_minute = bcdmin;
	OSD_time_second = bcdsec;
	OSD_time_track(OSD_TIME_REGION_MASK, 0); /* Enable time region */
	OSD_update_info();

	servo_info = temp_servo_info; /* put back real servo info */
    }
}

void showProgramTime(int type)
{
    int time;

    if (type!=-1)
        TimeMode = type;

    if (TimeMode==TIME_SINGLE_ELAPSED) {
        time = 0;
    }
    else if (TimeMode==TIME_SINGLE_REMAIN) {
        time = CurrentTrackTime;
       }
#ifdef HOST_SLAVE
	else if (TimeMode==TIME_TOTAL_ELAPSED) {
        time = currCDtime;
       }
#endif
    else {
        time = TotalRemainTime;
    }
    if ((SystemStatus == SYSTEM_STOP)|| type==-1) {
        show_panel_time(time);
    } else
        panel_running_time(ElapsedTime);

}

/*===========================================================================*/
void panel_time_mode_change(void)
{
    unsigned char *msg, *c_msg;
    

    /* only single elapsed is available in PBC ON. */
    if (((DiscMode & DISC_PBC_ON) && (SystemStatus == SYSTEM_PLAYING)) 
#if(defined(MP3) || defined(WMA_DEC))
        || STREAM_type
#endif
    ) {
	showProgramTime(TIME_SINGLE_ELAPSED);
	assign_osd_msg(msg, MSG_single_elapsed, c_msg, MSG_c_single_elapsed);
    } else {

#ifdef HOST_SLAVE
    if (codeOperand!=0){
	    TimeMode=codeOperand-1;
	} else
#endif
    {
        TimeMode++;
	}
	if (TimeMode > TIME_TOTAL_REMAIN)
	    TimeMode = TIME_SINGLE_ELAPSED;

	if (TimeMode == TIME_SINGLE_ELAPSED) {
	    showProgramTime(TIME_SINGLE_ELAPSED);
	    assign_osd_msg(msg, MSG_single_elapsed, c_msg, 
				MSG_c_single_elapsed);
	} else if (TimeMode == TIME_SINGLE_REMAIN) {
	    showProgramTime(TIME_SINGLE_REMAIN);
	    assign_osd_msg(msg, MSG_single_remain, c_msg, MSG_c_single_remain);
#ifdef HOST_SLAVE
	}else if (TimeMode == TIME_TOTAL_ELAPSED) {
	    showProgramTime(TIME_TOTAL_ELAPSED);
	    assign_osd_msg(msg, MSG_total_elapsed, c_msg, 
				MSG_c_total_elapsed);
#endif
	} else if (TimeMode == TIME_TOTAL_REMAIN) {
	    if (SystemStatus == SYSTEM_STOP)
		panel_running_time(0);
	    else
		showProgramTime(TIME_TOTAL_REMAIN);
	    assign_osd_msg(msg, MSG_total_remain, c_msg, MSG_c_total_remain);
	}
    }

    if (OSD_displayed_regions & OSD_TIME_REGION_MASK) {
	OUTOSD(OSD_FUNCTION_STATUS_REGION, msg, c_msg, QUICK_TIME_OUT);
    }
}

/*===========================================================================*/
void panel_running_time(int time)
{
    int	PlayTrack = cur_track_number;

    
#ifdef HOST_SLAVE    
     wtime=time;
     countdbg++;
#endif      
    /* host won't call this function if the current state is pause.*/
    /* save the current minute and second. 15-08-96 Alger */
    /* The playing time is still sending out either regular mode or */
    /* PBC ON mode */
    if (((DiscMode & DISC_PBC_ON) && (PlayTrack == 0) && (seg_sel))) {
        ElapsedTime = 0;
    } else {
        ElapsedTime = time;
    }

#ifdef SLIDE_SHOW_TIME
    if (TimeMode == TIME_SINGLE_ELAPSED && is_slide_show && seg_sel)
        time = adjCDtime(time, begCDtime, -1);
#endif
    if (TimeMode == TIME_SINGLE_REMAIN) {
#ifdef SLIDE_SHOW_TIME
        if (is_slide_show)
           time = adjCDtime(endCDtime, time, -1);
        else
#endif
           time = adjCDtime(CurrentTrackTime, time, -1);
#ifdef HOST_SLAVE
    }else if (TimeMode == TIME_TOTAL_ELAPSED){
	     time= currCDtime;	
#endif
    } else if (TimeMode == TIME_TOTAL_REMAIN) {
        time = adjCDtime(TotalRemainTime, time, -1);
	if (SystemStatus == SYSTEM_STOP) PlayTrack=1; /*force time display*/
    }

    /* if system mode is PBC ON, and PlayTrack is 0, we can't display */
    /* playing time */
    if (!((DiscMode & DISC_PBC_ON) && (PlayTrack == 0) && seg_sel)
#ifdef SLIDE_SHOW_TIME
	|| is_slide_show
#endif
    ) {
        show_panel_time(time);
    } else {
        time = 0;
    }

    OSD_time_minute = (time >> 16) & 0xff;
    OSD_time_second = (time >>  8) & 0xff;

#ifdef HOST_SLAVE
    welapsed=time;
#endif
}

/*===========================================================================*/
#define PROGRAM_INDEX_POS 9
#define PROGRAM_TRACK_POS (9+3)
static uchar     prg_buf[] = "PROGRAM PXX: XXX";
#ifdef BILINGUAL_OSD
#ifdef USE_CN_HEADER
#define CPROGRAM_INDEX_POS 7
static uchar     c_prg_buf[] = {
    CN_HEADER, CN_BIAN1, ' ', CN_HEADER, CN_CHENG2, ' ', 'P',
    'X', 'X', ':','X ', 'X','X ', '\0' };
#else
#define CPROGRAM_INDEX_POS 5
static uchar     c_prg_buf[] = {
    CN_BIAN1, ' ', CN_CHENG2, ' ', 'P', 'X', 'X', ':',  'X','X', '\0' };
#endif /* USE_CN_HEADER */
#define CPROGRAM_TRACK_POS (CPROGRAM_INDEX_POS+3)
#endif /* BILINGUAL_OSD */

void show_program_osd_number(int index, int track, int done)
{
    int i, tmp;
    
    
    tmp = (hex2bcd[index] << 12) | (D2A_COLON<<8) | hex2bcd[track];
    if (!done) tmp |= D2A_MINUS; /* for "10+" */
    /* tmp = "ii:tt" */
      prg_buf[PROGRAM_INDEX_POS] = '0'+(hex2bcd[index] >>4);
    prg_buf[PROGRAM_INDEX_POS+1] = '0'+(hex2bcd[index] & 0xf);
    prg_buf[PROGRAM_TRACK_POS+1] = '0'+(hex2bcd[track] >>4);
#ifdef BILINGUAL_OSD
    c_prg_buf[CPROGRAM_INDEX_POS] = '0'+(hex2bcd[index] >>4);
    c_prg_buf[CPROGRAM_INDEX_POS+1] = '0'+(hex2bcd[index] & 0xf);
    c_prg_buf[CPROGRAM_TRACK_POS+1] = '0'+(hex2bcd[track] >>4);
#endif

    if (done) {
	prg_buf[PROGRAM_TRACK_POS+2] = '0'+(hex2bcd[track] & 0xf);
#ifdef BILINGUAL_OSD
	c_prg_buf[CPROGRAM_TRACK_POS+2] = '0'+(hex2bcd[track] & 0xf);
#endif
    }
    else {
	prg_buf[PROGRAM_TRACK_POS+2] = '-';
#ifdef BILINGUAL_OSD
	c_prg_buf[CPROGRAM_TRACK_POS+2] = '-';
#endif
    }
 if(track>=100){
  prg_buf[PROGRAM_TRACK_POS] = '1';
#ifdef BILINGUAL_OSD
	c_prg_buf[CPROGRAM_TRACK_POS] = '1';
#endif
 }
 else
 	{
  prg_buf[PROGRAM_TRACK_POS] = ' ';
#ifdef BILINGUAL_OSD
	c_prg_buf[CPROGRAM_TRACK_POS] = ' ';
#endif
 }
 #if 0
    for (i = 2; i >= 0; i--) {
#ifdef BILINGUAL_OSD
	c_prg_buf[CPROGRAM_TRACK_POS+i] = 
#endif
	    prg_buf[PROGRAM_TRACK_POS+i] = T_digit2ascii[tmp&0xf];

	tmp <<= 4;
    }    
      
	if  ( track>=100){
	 // prg_buf[PROGRAM_TRACK_POS+2] =prg_buf[PROGRAM_TRACK_POS+3];
	   prg_buf[PROGRAM_TRACK_POS+2] =  '-';
	 
#ifdef BILINGUAL_OSD
	//c_prg_buf[PROGRAM_TRACK_POS+2] =  c_prg_buf[PROGRAM_TRACK_POS+3];
      c_prg_buf[PROGRAM_TRACK_POS+2] = '-';
	
#endif
      	}
	#endif
    OUTOSD(OSD_FUNCTION_STATUS_REGION, prg_buf, c_prg_buf, 0);
}

void program_osd_buf(uchar **msg_ptr, uchar **cmsg_ptr)
{
    *msg_ptr = prg_buf;
#ifdef BILINGUAL_OSD
    *cmsg_ptr = c_prg_buf;
#endif
}


/*===========================================================================*/