tcservo.c

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

	if (!timeout) {
	    /* Timeout to avoid hanging */
#ifdef FLASH_UPDATE
	    /* we may use getsectors() for "big" files */
	    tmp = (num>>6 - num>>9); /* ~(num/75) */
	    tmp = TWO_SECOND + tmp*ONE_SECOND;
	    next_time = glbTimer + tmp;
#else
            next_time = glbTimer + TWO_SECOND;/* Added by Mao Mar-28-2001 */
#endif /* FLASH_UPDATE */
	    do {
		if (forceDSAabort) return(-2);
#ifdef ECHO
		MIC_service();
#endif
	    } while (XPORT_active && (glbTimer < next_time));
	    xfer_done = 1;
	    TDM_found_begCDtime = 0;
	}
    } while (!xfer_done);
    /*
     * Victor: Because TDM will set end_of_play when CD_end is reached. We
     * will need to reset end_of_play here. It should be safe because when we
     * are getting PSD means we are not playing any playitem.
     */
    end_of_play = 0;

    return (1);
}


/*
 * Start playing from a given sector. There is no ending location!
 * Starting sector is specified in CD time format (i.e. MMSSFF where
 * each of MM/SS/FF is a BCD)
 *
 * This routine will always instruct the CD to go 10d frames earlier.
 *
 * Inputs:
 *	begin:		Starting CD sector time (in MMFFSS)
 *	vstream:	Video stream type (E0/E1/E2)
 *	size:		nonzero - Size of a CD sector (in bytes)
 *			0       - finish "step_by_step"..no init.
 *
 * Return:
 *	1:		successful
 *	0:		failure
 */
int playSectors(begin, vstream, size)
unsigned int begin, vstream;
int size;
{
    int return_val;

    if (size) {
	XPORT_active = 0;
	play_sector_state = PLAY_SECTOR_INIT;
    }

    do {
	return_val = playSectors_step_by_step(begin, vstream, size, 1);
	if ((return_val == 2) || (return_val == 3)) {
	    return (1);
	}
	if (return_val == 0) {	/* failed */
	    return (fuzzyPlaySector(begin, size));
	}
	if (XPORT_active)	/* when begCDtime == currCDtime */
	    return (1);

    } while (1);
}


/*****************************************************************************
 Step by step playSectors.
   size:		nonzero - Size of a CD sector (in bytes)
 			0       - finish "step_by_step"..no init.

 Returns 0 on failure. Returns 1 if don't know. Returns 2 if completed.
 Returns 3 if fuzzy.
 *****************************************************************************/
int playSectors_step_by_step(begin, vstream, size, fuzzy_allowed)
unsigned int begin, vstream;
int size, fuzzy_allowed;
{
    static int dsatime;
    static int go_failed;
    static int find_trials;
    static unsigned int previous_time;
    int status, adjdsa_time;

    if (XPORT_active)
	return (1);

    switch (play_sector_state) {

    case PLAY_SECTOR_INIT:

	XPORT_active = 0;
	TDM_isCDDA = 0;
	end_of_still = 0;

	/* 
	 * This routine will go through actual loading of XPORT ucode
	 * and CAM only if the current code doesn't match the bit
	 * stream type.
	 */
	XPORT_load_ucode(vcx_bitstream_type);
#if defined(ABNORMAL_VCD) || defined(ANTI_SHOCK)
            if (PLAY_set_2x_speed) {
                dsa_mode(MODE_ATTI_REL | MODE_CDROM | MODE_SPEED_DOUBLE);
                adjdsa_time = 0x30;
            } else
#endif
            {
                dsa_mode(MODE_ATTI_REL | MODE_CDROM | MODE_SPEED_NORMAL);
                adjdsa_time = 0x24;
            }

	vcx_user_video_stream = vstream;

	reset_dsa_go();
	begCDtime = begin;
	go_failed = 0;
	find_trials = 0;
        dsatime = adjCDtime(begCDtime, adjdsa_time, -1);
	play_sector_state = PLAY_SECTOR_DSA_GO;
	return (1);

    case PLAY_SECTOR_DSA_GO:
	status = dsa_go_step_by_step(dsatime);

#if 1
        if(status == 2) play_sector_state = PLAY_SECTOR_DSA_FIND_INIT;
        else if(status == 0) {
	    play_sector_state = PLAY_SECTOR_INIT;
	    return(0);      /* Really dead */
        } else return(1);
#else
	if (!status) {
	    /*if (forceDSAabort) return(0);*/	/* derek */
	    if ((go_failed >= 4) || forceDSAabort) {
		DEBUGINC(1, dbgPlaySector);
		play_sector_state = PLAY_SECTOR_INIT;
		return(0);	/* Really dead */
	    } else {
		/* retry time adjustments: 5, 20, 80, 320 (seconds) */
		adjdsa_time = 
		    logical2physical(375*ptrLshift[go_failed<<1]);
		adjdsa_time = adjCDtime(begCDtime, adjdsa_time, 1);
		if (adjdsa_time < endCDtime) {
		    begCDtime = adjdsa_time;
		    dsatime = adjCDtime(begCDtime, 0x10, -1);
		    reset_dsa_go();
		}
		go_failed++;
	    }
	} else if (status==2) {
	    play_sector_state = PLAY_SECTOR_DSA_FIND_INIT;
	}
	
	return(1);
#endif

    case PLAY_SECTOR_DSA_FIND_INIT:
	XPORT_play20video(XPORT_OFFSET_PLAY_SECTOR, vstream);
	TDM_turn_on();

	if (fuzzy_allowed) {
	    if (find_trials >= 2) {
		DEBUGINC(1, dbgPlaySector);
		XPORT_play20video(XPORT_OFFSET_FUZZY_PLAY, vstream);
		TDM_turn_on();

		XPORT_active = 1;
		vcx_pause = 0;
		return (3);
	    }
	}
	find_trials++;
	previous_time = glbTimer;
	play_sector_state = PLAY_SECTOR_DSA_FIND;

    case PLAY_SECTOR_DSA_FIND:
#ifdef ECHO
	MIC_service();
#endif

	if (XPORT_active == 0) {
	    /* from MPEG4 VCD project */
	    if (currCDtime == 0) {
		(volatile)mvd[tdmdata];
		if (glbTimer - previous_time > 4) {
		    /* XPORT should be up within 1/25 second */
		    goto go_again;
		}
	    }
	    if (currCDtime > begCDtime) {
		goto go_again;
	    } 
	    return (1);		
go_again:
	    /* Kill TDM ..so XPORT_active won't be set. */
	    mvd[tdmctl0] = 0x400;
	    mvd[tdmrcvslots0] = 0;
	    XPORT_active = 0;
	    
	    go_failed = 0;
	    play_sector_state = PLAY_SECTOR_DSA_GO;
	    
	    return (1);
	}
	/* Bingo! */
	play_sector_state = PLAY_SECTOR_INIT;
	vcx_pause = 0;
	return (2);

    default:
	return (0);
    }
}

/*
 * This routine is used to do fuzzy search.
 * Input:
 * 	time:	In CD sector format (i.e. MMSSFF where each of MM/SS/FF
 *		is a BCD value)
 *	size:	nonzero - Size of a CD sector (in bytes)
 *		0       - finish "step_by_step"..no init.
 *
 * Return:
 *	1:	successful
 *	0:	failure
 */
int fuzzyPlaySector(time, size)
int time, size;
{
    int retry = 2;


    /* Only change DSA mode if the current mode is not CDROM		 */
    TDM_isCDDA = 0;		/* Data is scrambled (as opposed to CDDA) */

    XPORT_load_ucode(vcx_bitstream_type);
#if defined(ABNORMAL_VCD) || defined(ANTI_SHOCK)
    if (PLAY_set_2x_speed)
        dsa_mode(MODE_ATTI_REL | MODE_CDROM | MODE_SPEED_DOUBLE);
    else
#endif
    dsa_mode(MODE_ATTI_REL | MODE_CDROM | MODE_SPEED_NORMAL);

    do {
	if (dsa_go(time))
	    break;
    } while (--retry);

    /* Regardless of dsa_go is OK or not. */
    XPORT_play20video(XPORT_OFFSET_FUZZY_PLAY, 0xe0);
    TDM_turn_on();

    if (retry) {
	/* start decoding */
	vcx_pause = 0;
	return (1);
    } else {
	return (0);
    }
}


/*
 * Play CDDA data from "begin" time to "end" time where both "begin" and
 * "end" are in absolute CD time format.
 *
 * Return:
 *	1:	successful
 *	0:	failure
 */
#define TDM_ON_AT_TRACK_BEGIN 0 /* this delays TDM turn on until track start */
int playCDDA(int track_start_time, int begin, int end)
{
    int retry = 3;

    extern RAMCODE RamCode;


    /* Kill TDM so when we restart, left/right will not swap	 */
    mvd[tdmctl0] = 0x400;
    mvd[tdmrcvslots0] = 0;
    system_audio_partial_reset(0);

#ifdef FRACTINT
    if (!FRACT_process_on) {
	FRACT_store = FRACTINT_START1;
	FRACT_process_on = 1;
    }
#endif

    /* Only change DSA mode if the current mode is not AUDIO		 */
    TDM_isCDDA = 1;		/* This is CDDA data (unscrambled PCM data) */
    vcx_playvideo_only = 0;

    XPORT_load_ucode(MPEG1_PS);	/* Only MPEG1_PS has CDDA ucode		*/
    dsa_mode(MODE_ATTI_REL | MODE_CDROM | MODE_SPEED_NORMAL);

    CDDA_play_time = adjCDtime(end, track_start_time, -1);

    CDDA_track_start_time = track_start_time;

    do {
	if (dsa_go(begin))
	    break;
    } while (--retry);

#if TDM_ON_AT_TRACK_BEGIN
    if (retry) {
	retry = glbTimer+ONE_SECOND; /* use "retry" as timeout */
	
	do {
	    SERVO_service();
	    
	    if ((run_time & x00ffffff) >= track_start_time) break;
	} while (retry>glbTimer);
    }
#endif TDM_ON_AT_TRACK_BEGIN

    /*
     * Regardless of dsa_go result, just turn on XPORT and TDM. Otherwise, if
     * high-level doesn't retry, we'll be stuck.
     */
#if 0
    save_ramcode = RamCode;
    VP_load_ucode(rcddamono);
#endif
    XPORT_restart_at(XPORT_OFFSET_PLAY_CDDA, 1);
    TDM_turn_on();

    return (retry);
}


void fill_screen(int color)
{
    DISP_Info *dip;
    int width;
    int height;

    dip = DISP_info + DISP_frame;

#if defined(MP3) || defined(WMA_DEC)
    /* For MP3/WMA use I-frame for display, since MP3/WMA shares B&P */
    if (STREAM_type) vcx_user_video_stream = 0xe1;
#endif

    if ((vcx_user_video_stream == 0xe2) || (vcx_user_video_stream == 0x1e2)) {
	DISP_frame = E2;
	width = 704;

	height = DISP_scn_height * 2;
    } else {
	DISP_frame = I;
	width = 352;
	height = 288; /* Set as PAL source */
    }

    vcx_VertSz = height;

    DISP_change_resolution(width, height);
    DISP_paint_screen(color, 0, DISP_frame);

    DISP_count = 0;
}

PRIVATE void init_dsa(void)
{
    /* clear all flags */
    CDinited = 0;
}




/************************************************************************
 * Routines specific to Philips' DSA interface protocol (Games 6001)	*
 ************************************************************************/
/* receive information from CD */
/* return dsa_word */
void receive_dsa(void)
{
    int CDDA_intro_time;

    /*
     * Talk with uP while receiving from DSA. Otherwise, uP may be left out
     * for long period of time, and it may think E3204 is dead.
     */
    check_user_input();

    if (OSD_update_time || (servo_info != last_servo_info)) {
	last_servo_info = servo_info;
	OSD_update_info();	/* in fsosd.c */
    }
}

/**************************************************
		DSA operation function
***************************************************/
/*
 * Set CD-module's modes.
 *
 * NOTE: SERVO has a bug, if it receives 2 trans_dsa(DSA_mode, mode) in
 *	 a "short" period of time, the mode is actually not changed
 *	 even though it will report the mode has been changed.
 *
 *	 Therefore, we can't use the standard way to retry dsa_mode.
 *	 At track boundary, we'll get SERVO_TRACK, SERVO_INDEX, SERVO_MIN,
 *	 and receive_dsa_all only retries 3 time, so we many not get
 *	 a chance to see SERVO_MODE_STATUS if we just retry like other
 *	 cases.
 *
 *	 When going into DOUBLE speed, the servo usually takes around
 *	 1 second to respond! When going into NORMAL speed, the response
 *	 time is a lot shorter.
 *
 * Input:
 *	mode:	set CD's mode
 *
 * Return:
 *	0:	fail
 *	1:	successful
 */
int dsa_mode(mode)
int mode;
{
    DISP_naicigam();

    currDSAmode = mode;

    return (1);
}


/*
 * This function simulates real dsa_release function by set the CDDA_play_time
 * to a big number, so the end_of_play will not be set until a track change.
 *
 * Return:
 *	1:	successful
 */
int dsa_release(unsigned int track_start, unsigned int track_end)
{
    CDDA_play_time = adjCDtime(track_end, track_start, -1);

    return (1);
}

/*
 * Stops playing the disk and brakes. This command also clears the
 * internal 'pause mode indicator'
 */
int dsa_stop(void)
{
    DISP_naicigam();

    SERVO_stop(1);
}

/*
 * Pause. This is for CDDA.
 */
int dsa_pause(void)
{
    target_min = (SERVO_Qarray_current[3] & 0x0000ff);
    target_sec = (SERVO_Qarray_current[4] >> 8 & 0x0000ff);
    target_frame = (SERVO_Qarray_current[4] & 0x0000ff);
    return (1);
}