cd7.c

来自「ESS3890+SL原代码（1*16内存）」· C语言 代码 · 共 699 行 · 第 1/2 页

 * depends on track number:
 *      0 <= track number <= 63
 *              track number
 *              control & address
 *              start time (min)
 *              start time (sec)
 *              start time (frm)
 *
 * This routine initialize track information as well as lead out time.
 *
 * Input:
 *      pTk:    Pointer to the track information buffer
 *      szTk:   Size (number of entries) of track information buffer
 *      num_of_session=1;
 * Return:
 *      0:      failed
 *      1:      OK
 */

int dsa_ltoc(pTk, szTk)
unsigned int * pTk;
int szTk;
{
    int track_rd_num;           /* # of track info have been read */
    unsigned char data;
    int i;
    int t64r, t65r, t66r;       /* Keep track whether we have received  *
                                 * 64h, 65h, 66h (A0, A1, A2)           */
    int ltoc_done;              /* LTOC is done                         */
    int retry_cnt = 0;          /* This routine's retry count           */
    int loopcnt;                /* Number of replies from servo.        */
    int tk1_ctl_adr;            /* Track #1 Control/Address             */
    int tk64_data;              /* Track #64 data                       */
 
    int timeout;
 
    CDinited = 0;               /* Avoid partially initialized CD info  */
 
    retry_cnt = 0;
 
/*    if (!servo_focus_on) {
      CDinfo.type = CD_NODISC;
      err_code = ERR_TRAYEMPTY;
      goto ltoc_err_return;
    }
*/
 
SERVO_ltoc_retry:
 
    if (servo_error_type==0x2) {  /*FOCUS_ERROR defined in servop.c*/
        CDinfo.type = CD_NODISC;
        err_code = ERR_TRAYEMPTY;
        goto ltoc_err_return;
    }
    
    if (retry_cnt >= 2) {
	CDinfo.type = CD_UNKNOWN;
        err_code = ERR_LTOC;
        goto ltoc_err_return;      /* Retried twice and still fails */
    }
 
    retry_cnt ++;
    /* initialize some CDinfo */
    CDinfo.type = 255;
    CDinfo.firsttrack = 0;
    CDinfo.lasttrack = 0;
        
    for (i = 0; i < szTk; i++)
        pTk[i] = xff000000;
    t64r = t65r = t66r = 0;
    track_rd_num = num_of_track = 0;
 
    /* process received data until it is done */
    loopcnt = ltoc_done = 0;
        SERVO_new_Qcode = 0;
 
    while (!ltoc_done) {
        VCX_service();
        check_user_input();
#ifdef LTOC_TV_CHANGE
	DISP_TV_service();
#endif
        
        loopcnt++;
        if (loopcnt > 2000) {
            /*
             * Servo is going crazy! This rarely happens; however, I have
             * seen this happened!
             */
	    SERVO_start_up();
            goto SERVO_ltoc_retry;
        }
 
        /* Higher priority command received. Go handle it */
	if ((loopcnt % 8) == 0)
	    if(SERVO_check_key_new()) return(0);
	
        timeout = glbTimer + FOUR_SECOND;
 
        do {
	    SERVO_service(1);
	    if (glbTimer > timeout){
		SERVO_start_up();
		goto SERVO_ltoc_retry;
	    }
	    if (SERVO_new_Qcode) {
		SERVO_new_Qcode = 0;
                break;
	    }
	    if (SERVO_check_key_new())
		return(0);

#ifdef LTOC_TV_CHANGE
	    DISP_TV_service();
#endif
        } while (1);
 
        switch (SERVO_Qarray_new[SERVO_QTRACK]) {
        case 0x00:
            switch (SERVO_Qarray_new[SERVO_QPOINT]) {
	    case 0xA0:
		CDinfo.firsttrack = bcd2hex[SERVO_Qarray_new[SERVO_QPMIN]];
		tk64_data = SERVO_Qarray_new[SERVO_QPSEC];
		if (tk64_data == 0xa)
		    CDinfo.type = CD_CDI;
		t64r = 1;
		break;
	    case 0xA1:
		CDinfo.lasttrack =
		    bcd2hex[SERVO_Qarray_new[SERVO_QPMIN]] - 1;
		
		if (CDinfo.type == CD_CDI)
		    num_of_track = -1;
		else
		    num_of_track =
			CDinfo.lasttrack - CDinfo.firsttrack + 1;
		t65r = 1;
		break;
		
	    case 0xA2:
		CDinfo.leadout = SERVO_Qarray_new[SERVO_QPMIN]<<16 ;
		CDinfo.leadout |= SERVO_Qarray_new[SERVO_QPSEC]<<8;
		CDinfo.leadout |= SERVO_Qarray_new[SERVO_QPFRAME];
		t66r = 1;
		break;
	    default:
		if ((SERVO_Qarray_new[SERVO_QPOINT] < 0xa0) &&
		    (SERVO_Qarray_new[SERVO_QPOINT] > 0x00)) {
		    int trk_index;
		    trk_index =
			bcd2hex[SERVO_Qarray_new[SERVO_QPOINT]] - 1;
		    if (pTk[trk_index] == xff000000) {
			pTk[trk_index] =
			    SERVO_Qarray_new[SERVO_QCTRADD] << 24;
			pTk[trk_index] |=
			    SERVO_Qarray_new[SERVO_QPMIN] << 16;
			pTk[trk_index] |=
			    SERVO_Qarray_new[SERVO_QPSEC] << 8;
			pTk[trk_index] |=
			    SERVO_Qarray_new[SERVO_QPFRAME];
#if 0 
			/* for single session DATA discs (MP3...) which have
			 * only one track, depending on the order of Q-code, 
			 * we may not have a chance to set tk1_ctl_adr. 
			 * tk1_ctl_adr can be more reliably set after all the
			 * TOC info has been acquired.
			 */
                        if (SERVO_Qarray_new[SERVO_QPOINT] ==
                                            CDinfo.firsttrack)
			    tk1_ctl_adr =
				SERVO_Qarray_new[SERVO_QCTRADD];
#endif
			track_rd_num++;
		    }
                            }
		break;
	    }
	    
            if ((t64r && t65r && t66r) && (track_rd_num > num_of_track))
                ltoc_done=1;
 
            break;
	    
	    
        default:
	    servo_jump(-64);
            break;
        }
    }   /* end of while(ltoc_done) */    
    
    /* set tk1_ctl_adr after getting all toc info */
    tk1_ctl_adr = pTk[CDinfo.firsttrack-1] >> 24;

    if ((tk1_ctl_adr & 0xcf) == 0x01) {
        CDinfo.type = CD_CDDA;
    } else if (tk64_data != 0 && 
	       (tk1_ctl_adr == 0x41 || tk1_ctl_adr == 0x61)) {
        CDinfo.type = CD_VCD;
	/* Note: Photo-CD will also pass as VCD */
    } else {
#ifdef DATA_CD
        if (!tk64_data)
            CDinfo.type = CD_DATA;
        else
#endif
	    CDinfo.type = CD_UNKNOWN;
    }    
    
    
    CDinited = 1;
    
#ifdef DEBUG_OSD
    OUTOSD(7, "LTOC", "", 3);
#endif
 
    dsa_stop();
    return(1);
 
ltoc_err_return:
    cd_stop = CDinited = 1;
    dsa_stop();
#ifdef DEBUG_OSD
    OUTOSD(7, "LTOC_ERR", "", 3);
#endif
 
    return(0);
}



/*
 * Goto time. This command forces the CD-module to jump to the requested
 * absolute time location.
 *
 * Input: 
 *	time:	CD sector time in MMSSFF format where each of MM/SS/FF
 *		is a BCD number.
 *
 * Return:
 *	1:	successful
 *	0:	otherwise
 */

/***************************************************************************
 * Goto time. This command forces the CD-module to jump to the requested
 * absolute time location.
 *
 * Input:
 *      time:   CD sector time in MMSSFF format where each of MM/SS/FF
 *              is a BCD number.
 *
 * Return:
 *      1:      successful
 *      0:      otherwise
 ***************************************************************************/
/*extern addrp; */
int dsa_go(unsigned int time)
{
    int return_val;
    int r_tmp;

    
    dsa_go_state = DSA_GO_INIT;
    
    
    do {
        if (SERVO_check_key_new())
	    break;
	SERVO_service(1);
        return_val = dsa_go_step_by_step(time);
    } while (return_val==1);
    
    VCX_service();
    return ((return_val == 2));   
}

int SERVO_dsa_go_state(void)
{
    return (dsa_go_state);
}

void reset_dsa_go()
{
    dsa_go_state = DSA_GO_INIT;
}

/****************************************************************************
 Step by step go time. Returns 0 if failed, 1 if don't know, 2 if succeed.
 ****************************************************************************/
int dsa_go_step_by_step(unsigned int time)
{
    int return_val;
    int r_tmp;

    switch (dsa_go_state) {
	
    case DSA_GO_INIT:
	if (time > CDinfo.leadout)
            time = CDinfo.leadout;
	if (time < 0x100) time = 0x100;
	
	if ( SERVO_mode == SERVO_STOP) {
	    SERVO_start_up();
	    return (1);
	}
	
	target_frame = time & 0x00ff;
	target_sec   = time >> 8 & 0x00ff;
	target_min   = time >> 16 & 0x00ff;
	
	return_val=SERVO_search_request();
	
	dsa_go_state = DSA_GO_ALMOST_DONE;
	return(1);  
	
    case DSA_GO_ALMOST_DONE:
	return_val=SERVO_search_request(); 
	
	if (return_val==2) {
	    
	    servo_info=0;
	    if(CDinfo.type != CD_CDI) {
		servo_info = (SERVO_Qarray_new[SERVO_QPOINT] << 16) |
		    (SERVO_Qarray_new[SERVO_QRMIN] << 8) |
		    SERVO_Qarray_new[SERVO_QRSEC];
	    } else {
		servo_info = currCDtime >> 8;
	    }
	    
	    r_tmp = bcd2hex[SERVO_Qarray_new[SERVO_QTRACK]];
	    if (CDinfo.type != CD_CDDA)
		r_tmp --;
	    servo_info |= (hex2bcd[r_tmp]<<24) & 0xff000000;
	    for(r_tmp=0; r_tmp<SUBQ_LEN; r_tmp++)
		SERVO_Qarray_current[r_tmp] = SERVO_Qarray_new[r_tmp];
	    
	    last_servo_info = servo_info;
	    updateLCDtime();
	    OSD_update_info();      /* OSD info needs to update */
	    SERVO_mode = SERVO_PLAY;
	    
	    dsa_go_state = DSA_GO_INIT;		
	} 
	return (return_val);
    default: 
	return(0);
    }
}