dsak.c

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

	    /* Timeout to avoid hanging */
#ifdef FLASH_UPDATE
	    /* we may use getsectors() for "big" files */
	    tmp = (num>>6 - num>>9); /* ~(num/75) */
	    tmp = ONE_SECOND + tmp*ONE_SECOND;
	    next_time = glbTimer + tmp;
#else
	    next_time = glbTimer + HALF_SECOND;
#endif /* FLASH_UPDATE */
	    do {
		if (SERVO_check_key_new()) return (-2);

	    } 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 {

	if(forceDSAabort)
	    return (-1);	/*derek*/


	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 */
	/*2_23_2000KCh, fix pause issue during track change, for MSERVO*/
    	{
#ifdef SAM_SRV
	    if(play_sector_state < PLAY_SECTOR_DSA_FIND_INIT)
		XPORT_active = 0;
	    else
#endif
		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 = 0x10;
            } else
#endif
            {
		dsa_mode(MODE_ATTI_REL | MODE_CDROM | MODE_SPEED_NORMAL);
                adjdsa_time = 0x3;
	    }
	    
    	    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 (!status) {
	    	if (go_failed >= 4) {
		    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, 0x03, -1);
			reset_dsa_go();
		    }
		    go_failed++;
	    	}
            } else if (status==2) {
		play_sector_state = PLAY_SECTOR_DSA_FIND_INIT;
	    }

	    return(1);

	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);
	        }
	    }

#ifdef ANTI_SHOCK
	    if (ABV_set_good){
		ABV_set_good = 0;
		ABV_wrptr = ABV_gdptr;
	    }
#endif ANTI_SHOCK

	    find_trials++;
	    previous_time = glbTimer;
	    play_sector_state = PLAY_SECTOR_DSA_FIND;

	case PLAY_SECTOR_DSA_FIND:
	    check_user_input();
	    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	1
int playCDDA(int track_start_time, int begin, int end)
{
    int return_val;

    XPORT_active = 0;
    play_cdda_state = PLAY_CDDA_INIT;

    do {
	if(forceDSAabort)
	    return (-1);

	return_val = playCDDA_step_by_step(track_start_time, begin, end, 0);
	if ((return_val == 2)) {
	    /* success */
	    return (1);
	}
	if ((return_val == 3)) {
	    /* fuzzy */
	    return (2);
	}
	if (return_val == 0) {	/* failed */
	    return(0);
	}
    } while (1);
}

int playCDDA_step_by_step(int track_start_time, int begin, int end, int match)
{
    int status;
    static int retry_cnt;


    if (XPORT_active)
	return(1);

    switch (play_cdda_state) {
    case PLAY_CDDA_INIT:
	/* Kill TDM so when we restart, left/right will not swap	*/
	mvd[tdmctl0] = 0x400;
	mvd[tdmrcvslots0] = 0;

	if (!match) {
	    system_audio_partial_reset(0);
#ifdef ANTI_SHOCK
	    XPORT_load_ucode(MP3_PS);	/* MP3_PS has ESP ucode */
#else
	    XPORT_load_ucode(MPEG1_PS); /* MPEG1_PS has CDDA ucode */
#endif
	    CDDA_play_time = adjCDtime(end, track_start_time, -1);
	    CDDA_track_start_time = track_start_time;

	    /* 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;

#ifdef ANTI_SHOCK
#ifdef NO_CDDA_COMPRESS
	    REC_compress_ratio = 1;
#else
	    /* default is G.721 */
	    REC_compress_ratio = 4;
	    REC_4to1_coder_init();
	    REC_4to1_decoder_init();
#endif /* NO_CDDA_COMPRESS */
#endif /* ANTI_SHOCK */
	}

#ifdef ANTI_SHOCK
	if (PLAY_set_2x_speed) {
	    CPRINTF("2X SPEED", CDDA_play_time);
	    dsa_mode(MODE_AUDIO | MODE_SPEED_DOUBLE);
	} else
#endif /* ANTI_SHOCK */
	{
	    CPRINTF("1X SPEED", CDDA_play_time);
	    dsa_mode(MODE_AUDIO | MODE_SPEED_NORMAL);
	}
	play_cdda_state = PLAY_CDDA_XPORT_START;
	return(1);

    case PLAY_CDDA_XPORT_START:
#ifdef ANTI_SHOCK
	if (match) {
	    XPORT_load_cdda_match();
	    XPORT_restart_at(XPORT_OFFSET_MATCH_DATA, 1);
	} else
#endif
	{
	    XPORT_restart_at(XPORT_OFFSET_PLAY_CDDA, 1);
	}
	retry_cnt=0; /* initialize */
	play_cdda_state = PLAY_CDDA_DSA_GO;
	dsa_go_state = DSA_GO_INIT;

	return(1);

    case PLAY_CDDA_DSA_GO:
	status = dsa_go_step_by_step(begin);
	if (!status) {
	    if (retry_cnt >= 2) {
		DEBUGINC(1, dbgPlaySector);
		play_cdda_state = PLAY_CDDA_INIT;
		return(0);	/* Really dead */
	    }

	    retry_cnt++;
	} else if (status==2) {
#if TDM_ON_AT_TRACK_BEGIN
	    retry_cnt = glbTimer + ONE_SECOND; /* use retry_cnt as timeout */
	    play_cdda_state = PLAY_CDDA_WAIT_BEGIN;
	    CPRINTF("CDDA WAIT", SERVO_cdtime);
#else
	    play_cdda_state = PLAY_CDDA_TDM_ON;
#endif TDM_ON_AT_TRACK_BEGIN
	}

	return(1);

#if TDM_ON_AT_TRACK_BEGIN
    case PLAY_CDDA_WAIT_BEGIN:
	if (retry_cnt < glbTimer) {
	    play_cdda_state = PLAY_CDDA_TDM_ON;
	} else {
	    SERVO_service(1);

	    if (SERVO_cdtime < begin) return(1);

	    CPRINTF("CDDA BEGIN", SERVO_cdtime);
	    play_cdda_state = PLAY_CDDA_TDM_ON;
	}
#endif TDM_ON_AT_TRACK_BEGIN

    case PLAY_CDDA_TDM_ON:
	TDM_turn_on();
	CPRINTF("TDM ON", retry_cnt);
#ifdef ANTI_SHOCK
	if (match) {
	    /* use "retry_cnt" as timeout */
	    retry_cnt = glbTimer+TWO_SECOND;

	    ABV_xfer_flag = 0; /* "1" when CDDA data comes in */
	    play_cdda_state = PLAY_CDDA_MATCH;
	    return(1);
	} else
#endif
	{
	    XPORT_active = 1;
	    play_cdda_state = PLAY_CDDA_INIT;
	    return(2);
	}
	break;

#ifdef ANTI_SHOCK
    case PLAY_CDDA_MATCH:
	if (ABV_xfer_flag) {
	    XPORT_active = 1;
	    play_cdda_state = PLAY_CDDA_INIT;
	    CPRINTF("ESP DATA MATCH", c2po);
	    return(2);
	} else {
	    /* timeout if not scratched disc */
	    if ((retry_cnt < glbTimer) &&
		(c2po_timeout < glbTimer) ) { /* "fuzzy" play for CDDA */
		/* Kill TDM so when we restart,
		 * left/right will not swap	*/
		mvd[tdmctl0] = 0x400;
		mvd[tdmrcvslots0] = 0;
		TDM_force_stop(1);
		ABV_stop_filling();

		XPORT_restart_at(XPORT_OFFSET_PLAY_CDDA, 1);
		TDM_turn_on();
		ABV_start_filling();
		XPORT_active = 1;
		CPRINTF("ESP FUZZY MATCH", c2po);

		play_cdda_state = PLAY_CDDA_INIT;
		return(3);	/* fuzzy */
	    }
	    return(1);
	}
#endif ANTI_SHOCK

    }
}


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)	*
 ************************************************************************/
/*
 * Transmit "cmd" and "data" from our chip to servo.
 *
 * Inputs:
 *	cmd:	servo command
 *	data:	associated data
 */