podigest.c

来自「一个不错的硬盘播放器程序,包含VFD显示程序,红外线遥控程序,硬盘读写程序,及解」· C语言 代码 · 共 777 行 · 第 1/2 页

{
    short digestLuminanceLevel;
    subDigestFinish = orNot;

#ifdef LATER
    if(orNot) {
	/* read accumulator value */ 
	VP_READ(digestLuminanceLevel); 
	/* normalize it */
	DDSIMPLE(digestLuminanceLevel);
	DDSIMPLE(digestNumMB);
	assert(digestNumMB>0);
	digestLuminanceLevel= ((digestLuminanceLevel<<1)/digestNumMB);
	DDSIMPLE(digestLuminanceLevel);
    }
    return (digestLuminanceLevel);
#else
    return;
#endif
}

/*
 * Routine to call when digest run to E2 data.
 */
#ifdef LATER
void digestE2(digit)
int digit;
{
    subDigestFinish = 0;
    if (digit) {
	dgst_wr_num(digest_track, COLOR_WHITE, COLOR_BLACK, 8, FILL_E2);
    }
    incDigestTrack();
}
#endif

/*
 * This routine is called from what_todo(). It is responsible for
 * advancing to the next digest picture.
 */
void decideDigestVideoOrAudio()
{
#if (P3O || P4O)
    /* In case the NEXT command we send to CD loader doesn't take *
     * effect, we send it again after some time			  */
    if (glbTimer >= resendNextTime ) {
	PO_ASSERT_SKIP;
	CLEAR_RESEND;
    }
    else 
#endif
    if (glbTimer >= subDigestEndTime) {
	/*
	 * Taking too long (maybe the disk is bad and we can't find
	 * the number of I frames that we are looking for.) Consider
	 * done with the current track. Skip to the next track.
	 */
	nextSubDigest();
    } else if (subDigestFinish) {	/* Picture is shown		*/
	int audioTimeLeft; /* Time from the end of clip (in 1/64 sec)	*/
	int audioElapsed;  /* Time since we started audio (in 1/64 sec)	*/
    
	CLEAR_RESEND;	/* Data come in already, no need to resend.	*/

	audioElapsed  = glbTimer - digestAudioStart;

	if (!audio_in_digest || TDM_isCDDA) {
	    /*
	     * If we don't have simultaneous digest video+audio or
	     * we are playing CDDA, then play a little segment of
	     * audio after video/logo stops.
	     */
	    audioTimeLeft = vcx_digest_audio_duration - audioElapsed;
	} else audioTimeLeft = 0;

	if (!vcx_playaudio_only && !digestAudioStart) {
	    /*
	     * Picture just shown. Send the number, also start audio.
	     */
	    dgst_wr_num(digest_track, COLOR_WHITE, COLOR_BLACK, 8, FILL_E2);
	    if (TDM_isCDDA || (showIframe == 0)) {
		vcx_playaudio_only = 1;
		vcx_playvideo_only = 0;
		digestAudioStart = glbTimer;	/* Save starting time	*/
		showIframe = digestIframe2show;
		incDigestTrack();
	    } else {
		showIframe--;
		subDigestFinish = 0;
	    }
	} else if (audioTimeLeft <= 0) {
	    nextSubDigest();
#ifdef FADING_CONTROL
	} else if (audioElapsed < FADING_DURATION) {
	    /*
	     * Audio fade in (first second)
	     */
	    vcx_fade_audio_volume =
	      fadeOutAudio(vcx_audio_volume, audioElapsed);
	} else if (audioTimeLeft < FADING_DURATION) {
	    /*
	     * Audio fade out (last second)
	     */
	    vcx_fade_audio_volume = 
	      fadeOutAudio(vcx_audio_volume, audioTimeLeft);
	} else {
	    /*
	     * Restore normal volume
	     */
	    vcx_fade_audio_volume = 0x1010;
#endif				/* FADING_CONTROL */
	}
    }
}


/*
 * This routine is called if CD is idled for 5 seconds while we are
 * in digest mode.
 */
void quitDigest()
{
    /*
     * We are in the middle of digest, and data is interrupted for
     * 5 seconds. We should quit digest mode
     */
    if (showIframe != digestIframe2show) {
	incDigestTrack();
	showIframe = digestIframe2show;
    }
    
    ignoreTDM = 0;
    clearIgnoreTime = 0xffffffff;
    resetDigest();
}


/*
 * Done with digest. Reset digest related variabled and switch 
 * screen.
 */
void resetDigest()
{
    vcx_digest = 0;		/* No longer in digest mode		*/
    viewTrack = 0;		/* Not "TRACK VIEW" mode		*/
    vcx_playvideo_only = 0;
    vcx_playaudio_only = 0;
    scanMode = SCAN_OFF;

    digestPause = 0;		/* No longer pausing in digest		*/

    digestAudioStart = 0;
    subDigestEndTime = 0xffffffff;
    CLEAR_RESEND;
    signalFinishSubDigest(0);	/* Reset subDigestFinish		*/

    if (digestInited) {
	digestInited = 0;
	vcx_fade_audio_volume = 0x1010;
    }
    showingLogo = SHOWING_NOLOGO; /* Just paint the screen. So no logo	*/

    /*
     * The current display is really in E2 format; however, input data
     * has been in E0 format. So we need to do an emergency save, then
     * set display frame and screen frame to 3 (so we can keep the screen
     * data 'til new data come in)
     */
    cleanSystemState();
    DISP_frame = E2;

    /*
     * FAKE!! It doesn't match future input. So we'll always force
     * a screen change regardless of real incoming data type.
     */
    keepVideoType = 0;
}

#ifdef NEW_DIGEST_OSD

int top_left;

PRIVATE void one_byte_becomes_one_dword(int b, int *dw)
{
    int  i, x;
    char *cp;

    x = *dw;
    cp = (char *)(&x);
    for (i=0; i<4; i++) {
	switch (b & 0xc0) {
	    case 0xc0: *cp = 0x7b; break;
	    case 0x40: *cp = 0xb2; break;
	}
	b <<= 2;
	cp++;
    }
    *dw = x;
}

PRIVATE void DGST_overlay(int num, int addr)
{
    int *fp = (int *)(T_dgs_font + 16*num);
    int *dp = (int *)dram(addr);
    int i, j, dw;
    char *cp;

    for (j=0;j<DGST_FHEIGHT;j++) { 
    	dw = *fp++;
    	cp = (char *)(&dw);
        for (i=0;i<4;i++) { 
	    one_byte_becomes_one_dword(*cp, dp);
	    cp++; dp++;
        }
	dp += 4;
    } 
}

PRIVATE void DGST_wr_num(int num) 
{ 
    int dst = DISP_END - (26*8) - (32*16/4);
    int num1, num0;

    num1 = num/10; 
    num0 = num - num1*10; 

    if (num1) {
	DGST_overlay(num1, dst);
	DGST_overlay(num0, dst+4);
    } else
    	DGST_overlay(num0, dst);

    VP_xfer(50, VPCMD_W_DPCM, 0, VPDMA_USEDX, dst, 8, 16);

    VP_xfer_bf(0, VPCMD_R_DPCM, 0,
		VPDMA_BREAK+VPDMA_INC2+VPDMA_WIDTH1, top_left, 4, 16);
    VP_xfer_bf(0, VPCMD_R_DPCM, 8,
		VPDMA_BREAK+VPDMA_INC2+VPDMA_WIDTH1, top_left+3, 4, 16);
} 

#else	/* NEW_DIGEST_OSD */

/* 
 * write a number at special position, number can not be larger than 99.
 *	num:	Up to to digit number to write
 *	fc:	front color
 *	bkc:	background color
 *	blend:	overwrite/transparent 
 *	frame:	which frame (E2)
 */
PRIVATE void DGST_wr_num(num, fc, bkc, blend, frame) 
char num;
int fc, bkc, blend, frame;
{ 

    int offsetX, offsetY; 
    char subnum, dnum;

    subnum = num % 10; 
    dnum = num / 10; 

    offsetY = DGST_SUBSCRH * (((num - 1) % 9) / 3) + DGST_FIRST_STARTY;

    if (DISP_scn_height == 288)	/* PAL ??? note:  Y_PAL = Y_NTSC * 6 / 5 + 4 */
      offsetY = offsetY * 6 / 5 + 8;
    offsetX = DGST_FIRST_STARTX + (((num - 1) % 9) % 3) * DGST_SUBSCRW;        
                                                       
    if (dnum) { 
	DGST_wr_numxy(dnum, fc, bkc, blend, frame, offsetX, offsetY); 
	offsetX += 12;		/* move to next digital */ 
    } 
    DGST_wr_numxy(subnum, fc, bkc, blend, frame, offsetX, offsetY);
} 

/* 
 * write a number at special position, notice: only one digital.           
 *	num:	digit to write
 *	fc:	front color                                                 
 *      bkc:	background color                                            
 *      blend:  overwrite/transparent                                       
 *      frame:  Target frame (E2)                                            
 *	x:	X co-ordinate
 *	y:	Y co-ordinate
 */ 
PRIVATE void DGST_wr_numxy(num, fc, bkc, blend, frame, x, y) 
char num;
int fc, bkc, blend, frame, x, y;
{ 
    int mask, div; 
    short i, j; 
    int color; 
    unsigned long * font = T_dgs_font;

    for (j = 0; j < DGST_FHEIGHT; j++) { 
	mask = 0xc00000; 
	div = 0x400000; 
	for (i = 0; i < DGST_FWIDTH; i++) { 
            switch ((int)(font[num*DGST_FHEIGHT+j] & mask) / div) { 
              case 3:			/* front color */ 
                DISP_paint_dot(x+i,y+j,fc,blend,frame); 
                break; 
#if 1
              case 1: 
		color = COLOR_BLUE;	/* it is edge, color=blue */ 
		DISP_paint_dot(x+i, y+j, color, blend, frame); 
		break; 
#else 
              case 0:			/* background */ 
                DISP_paint_dot(x+i, y+j, bkc, blend, frame); 
                break; 
#endif 
            } 
            mask >>= 2; 
	    div >>= 2;
	} 
    } 

} 
#endif	/* NEW_DIGEST_OSD */

#ifdef LATER
/*
 * Called from mpeg1v.c to paint over the old area before filling
 * with new data. This way, we can avoid problems with pictures of
 * different sizes.
 */
void fillSubDigest()
{
    unsigned short yval, uval, vval;
    int yrows, urows;
    int yoff;
    int index;
    int ycols, ucols;

    if (showIframe != digestIframe2show) 
      return;	/* Painted over already	*/

    yval = y_array[digestBackground];
    uval = u_array[digestBackground];
    vval = v_array[digestBackground];

    if (vcx_subDigestPerPage == 9) {
      index  = (digest_track + 8) % 9;
      yrows = vcx_scn_height>>1;
      yoff = yoffset33_Y_for_fillSubDigest(index);
      ycols = subDigestXSpacing33;
    } else {
      index = (digest_track + 3) % 4);
      yrows = vcx_scn_height;
      yoff =  (index/2)*vcx_scn_height;
      ycols =  subDigestXSpacing22*3/4;
    }
    urows = yrows>>1;
    ucols = ycols>>1;


    sendconstant(yval, E2FRAME_Y_Y + yoff, yrows, 
		 E2FRAME_Y_X + xoffsetY, ycols);
    sendconstant(uval, E2FRAME_U_Y + (yoff >> 1), urows,
		 E2FRAME_U_X + xoffsetU, ucols);
    sendconstant(vval, E2FRAME_V_Y + (yoff >> 1), urows,
		 E2FRAME_V_X + xoffsetU, ucols);
}
#endif

/************************************************************************
 * Following routines are used some where else. Since they are not	*
 * time critical and we want to protect the source, we put them here	*
 ************************************************************************/
int checkSubDigestRange(int MBRow, int MBColumn)
{
    int tmpMBRow;
    int tmpMBColumn;
    if (vcx_digest) {
	tmpMBRow = MBRow;
	tmpMBColumn = MBColumn;
	if(vcx_subDigestPerPage ==9) {
	    tmpMBRow>>=1;
	    tmpMBColumn>>=1;
	}
    }
    return (((tmpMBColumn >= Hgap) && (tmpMBColumn < (Hgap + XoffsetEndY))) &&
	    ((tmpMBRow    >= Vgap) && (tmpMBRow    < (Vgap + YoffsetEndY))) &&
	    ((vcx_subDigestPerPage == 4) || !((tmpMBColumn >> 1) & 1)));
}

#endif