podigest.c

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

/* Copyright 1996, ESS Technology, Inc.					*/
/* SCCSID @(#)podigest.c	1.21 12/22/97 */

/*
 * This is modified from version 1.76 of 3204's podigest.c
 */

/*
 * $Log$
 */

#ifdef DIGEST
#include "util.h"
#include "fsosd.h"
#include "display.h"
#include "vcxi.h"
#include "digest.h"
#include "timedef.h"
#include "tdm.h"
#include "mvd.h"
#include "tact.h"
#include "debug.h"
#include "ir.h"
#include "vp.h"
#include "sysinfo.h"
#include "const.h"

/*
 * Undefine fading control. Audio fade in/out doesn't seem to give "good"
 * result (expecially if we want to implement "track digest"
 */
#undef FADING_CONTROL

/************************************************************************
 * Local defines.							*
 ************************************************************************/
#define yoffsetGlobal33_Y_for_fillSubDigest (DEST_HEIGHT==288?84:62)
#define	yoffsetGlobal33_Y	((DEST_HEIGHT >> 2) - VGAP33)

#define yoffset_Y(index) 	((vcx_subDigestPerPage == 9) ?		\
				 yoffset33_Y(index)	     : 		\
				 yoffset22_Y(index, HGAP22, xoffsetEnd22_Y))

#define DFACTOR 2	/* decimate factor: hardwired to 2 */
#define D_CHAR_WIDTH 	(OSD_CHAR_WIDTH/DFACTOR)
#define D_CHAR_HEIGHT 	(OSD_CHAR_HEIGHT/DFACTOR)
#define FADING_DURATION (ONE__SEC)	/* (second) */

/* scratch area for digest osd fonts */
/* use one row of D_CHAR_HEIGHT x D_CHAR_WIDTH*10 */
#define XOFFSET_SCRATCH		0
#define YOFFSET_SCRATCH 	864
#define OSD_XPOS(index) 	(XOFFSET_SCRATCH + (index) * MYDX)
#define MYDY 			D_CHAR_HEIGHT
#define MYDX 			(D_CHAR_WIDTH >> 2)
#define SOURCE_WIDTH		(352 >> 2)
#define SOURCE_HEIGHT		vcx_VertSz
#define DEST_HEIGHT		vcx_scn_height
#define DGST_MAXFRAME		5 

#define DGST_FWIDTH		12	/* Width of digest font		*/ 
#define DGST_FHEIGHT		16 	/* Height of digest font	*/
#define DGST_SUBSCRW		160	/* Width of digest subscreen	*/ 
#define DGST_SUBSCRH		120 	/* Height of digest subscreen	*/
#define DGST_FIRST_STARTX	104	/* Digest start x		*/ 
#define DGST_FIRST_STARTY	64	/* Digest start y		*/ 
 

/* john also got left shifted by 2 */
#define CIFMODE			0

#define assignDigestIndex(tmp, col, john)				\
{									\
    (tmp).bYte[3-(col)] = (((unsigned long)john) >> 31) ? 0x7f : 0x80;	\
    (john) <<= 4;							\
}

/************************************************************************
 * Global variables							*
 ************************************************************************/
int		vcx_digest_audio_duration = THREE_SECOND; /* Number of 	*
					 * audio seconds		*/
char		digestIframe2show = 6;	/* Number of I frames to show 	*
					 * before freezing		*/
int		xoffsetY;
int		yoffsetY;
unsigned int	subDigestPeriod = FIFTEEN_SECOND; /* Max. 15 sec for each*
					 * digest screen; this is on	*
					 * top of other constraints.	*/
#if 0
char		DigestFrameToSkip;	/* Number of frames to skip in	*
					 * digest (before the first I)	*/
#endif
char		audio_in_digest = 0;	/* Play audio during digest if 1*/

/************************************************************************
 * Private variables							*
 ************************************************************************/
PRIVATE int	subDigestFinish;/* flag to increment the digest track	*/
PRIVATE int	digestInited = 0;
#if 0
PRIVATE int	xoffsetOsdY;
PRIVATE int	yoffsetOsdY;
#endif
PRIVATE int	Vgap;
PRIVATE int	Hgap;
PRIVATE int	YoffsetEndY;
PRIVATE int	XoffsetEndY;
PRIVATE	int	digest_track;	/* current track to be digested		*/
PRIVATE	int	prevDigestTck;	/* The last digest track number, so we	*
				 * can make sure that digest track	*
				 * number is increasing			*/
PRIVATE	char	showIframe;	/* Number of I frames to show before	*
				 * starting audio.			*/


#if (P3O || P4O)
PRIVATE unsigned int resendNextTime = 0xffffffff;   /* Time we will 	*
				 * resend NEXT track			*/
#define	SET_RESEND	resendNextTime = glbTimer + resend_delay
#define	CLEAR_RESEND	resendNextTime = 0xffffffff
#else
#define	SET_RESEND
#define	CLEAR_RESEND
#endif

/************************************************************************
 * Functions private to this module					*
 ************************************************************************/
PRIVATE void	digestAdvanceTrack(void);
PRIVATE void	digestOsd(int index, int xoffset, int yoffset, int pos);
#ifdef FADING_CONTROL
PRIVATE int	fadeOutAudio(int, int);
#endif
PRIVATE	void	incDigestTrack(void);
#ifdef NEW_DIGEST_OSD
PRIVATE void    DGST_wr_num(int);
#define dgst_wr_num(a,b,c,d,e) DGST_wr_num((a))
#else
PRIVATE void    DGST_wr_num(int,int,int,int,int);
PRIVATE void 	DGST_wr_numxy(int,int,int,int,int,int,int); 
#define dgst_wr_num(a,b,c,d,e) DGST_wr_num((a),(b),(c),(d),(e))
#endif
PRIVATE	void	nextSubDigest(void);

/*
 * Increment digest_track. We'll limit it to 99 (for OSD purpose)
 */
PRIVATE void incDigestTrack()
{
    digest_track++;
    if (digest_track > 99) digest_track = 1;
}


/*
 * Initialize digest. This routine is responsible for:
 *	1. Set variables related to digest.
 *	2. Move fonts needed for digest OSD to scratch DRAM. Also
 *	   process the font accordingly.
 *	3. A smooth screen resolution conversion.
 */
PRIVATE void initDigest()
{
    VP_load_ucode(rtwo2one);
    showIframe = digestIframe2show;
#if 0
    subDigestEndTime = glbTimer +subDigestPeriod;
				/* Scheduled end time for first track	*/
#else
    subDigestEndTime = 0xffffffff; /* Don't rush user. Let him have	*
				 * some time to press the play key.	*/
#endif

#if (P1O || P2O || P4O)
    digestPause = 1;		/* Don't time out from digest mode.	*
				 * Give customer time for inputing	*/
#endif

    vcx_digest = 1;		/* We are in digest mode		*/

    /* audio_in_digest decide start with video (first picture) or play 	*
     * audio during digest*/
    vcx_playvideo_only = audio_in_digest ? 0 : 1;

    vcx_playaudio_only = 0;	/* No audio at beginning		*/

    /* 
     * In case we enter digest mode again while we just finished digest
     * and waiting for user to make a choice.
     */
    ignoreTDM = 0;		
    clearIgnoreTime = 0xffffffff;

    if (!digestInited) {
	digestInited = 1;
    }

    DISP_frame = E2;
    DISP_change_resolution(704, DISP_scn_height*2);
    DISP_paint_screen(COLOR_BLUE, NORMAL_PAINT, DISP_frame);
    DISP_count = 0;

    showingLogo = SHOWING_NOLOGO;/* Digest is no longer showing logo	*/
}

void setupSubDigestScreen()
{
    int index = (digest_track+(vcx_subDigestPerPage-1)) % vcx_subDigestPerPage;

    if (vcx_subDigestPerPage == 9) {
	/* order in assigning is important */
	YoffsetEndY = yoffsetEnd33_Y;
	XoffsetEndY = xoffsetEnd33_Y;
	Vgap	= VGAP33;
	Hgap	= HGAP33;

	/* the following have dependency on the previous variables */
	xoffsetY = xoffset33_Y(index);
	yoffsetY = yoffset33_Y(index);
    } else {
	YoffsetEndY = yoffsetEnd22_Y;
	XoffsetEndY = xoffsetEnd22_Y;
	Vgap	= VGAP22;
	Hgap	= HGAP22;

	xoffsetY = xoffset22_Y(index,HGAP22,xoffsetEnd22_Y);
	yoffsetY = yoffset22_Y(index,VGAP22,yoffsetEnd22_Y);
    }

    /* 
     * caculate the y and uv offsets in long word address for the next 
     * decoded picture. 
     */
    { 
    	int offset = yoffsetY * DMAWIDTH2_E2_UV;
    	digest_y_offset = xoffsetY + (offset<<1);
    	digest_uv_offset = (xoffsetY>>1) + (offset);
    }
}

/*
 * Advance a picture
 *
 */
PRIVATE void digestAdvanceTrack(void)
{

    setupSubDigestScreen();
    signalFinishSubDigest(0);	/* Reset subDigestFinish		*/
    digestAudioStart = 0;
}


#ifdef FADING_CONTROL
/*
 * Compute vcx_audio_volume based on a factor. This routine is used
 * to do audio fade in/out.
 *
 * Inputs:
 *	vol:	current audio volume
 *	factor:	Multiplication factor.
 */
PRIVATE int fadeOutAudio(vol, factor)
int vol;
int factor;
{
    union {
	unsigned char byte[2];
	unsigned short word;
    } john;

    john.word = (unsigned short) vol;
    john.byte[0] = (unsigned char) (((unsigned long) john.byte[0] * factor) 
				    >> 6);
    john.byte[1] = (unsigned char) (((unsigned long) john.byte[1] * factor) 
				    >> 6);
    return (int) john.word;
}
#endif

/*
 * Action to taken when we are done with one digest picture
 */
PRIVATE void nextSubDigest()
{
    /*
     * Done with one digest screen. Let's get next picture.
     * For the timebeing, turn audio off; wait for first picture.
     */
    vcx_playaudio_only = 0;
    /* audio_in_digest decide start with video (first picture) or play 	*
     * audio during digest*/
    vcx_playvideo_only = audio_in_digest ? 0 : 1;

    vcx_fade_audio_volume = 0x1010;
    /* Make sure we are moving forward with digest track number */
    if (prevDigestTck == digest_track) incDigestTrack();
    prevDigestTck = digest_track;

    /* Decide what to do next */
#if (P3O || P4O)
    if (1) {
#else
    if (digest_track <= 18) {
#endif
	subDigestEndTime = glbTimer + subDigestPeriod;
				/* Scheduled end time for next track	*/

	if (!viewTrack) {
	    if (((digest_track-1) % vcx_subDigestPerPage) == 0) {
#if (P1O || P2O || P4O)
		/*
		 * After 4/9 pictures, pause, and wait for user input
		 */
		assertPause();
		/* Don't time out while allowing user to do selection */
		subDigestEndTime = 0xffffffff;
		digestPause = 1;	/* Pausing, so ignore timeout stuff*/
		/*
		 * Customer can select it message.
		 */
		OUTOSD(OSD_VIEW_REGION, MSG_digest_pause, 
		       MSG_c_digest_pause, 0);
#else
		skipTrack();
		SET_RESEND;	/* Start a resend timer (just in case)	*/
#endif
	    } else {
		skipTrack();
		SET_RESEND;	/* Start a resend timer (just in case)	*/
		digestPause = 0;	/* No longer pausing.		*/
	    }
	}
	  
	digestAdvanceTrack();
    } else {
	/*
	 * Stopped because we hit 18 pictures. In which case,
	 * we'll ignore TDM input for 20 seconds. After that, we
	 * do decoding again.
	 */
	ignoreTDM = 1;
	clearIgnoreTime = glbTimer + TWENTY_SECOND;
	resetDigest();
    }
}

/************************************************************************
 * Functions to interface with outside world.				*
 ************************************************************************/
/*
 * Do disk digest
 *
 * Input parameter is not used for play-only machines.
 */
int digestPage(int next)
{
#ifdef LATER    
extern int VscaleReady;
    VscaleReady = 0;  /* force no scaling when digest is on */
    InitVscale();
#endif    
    assert((vcx_subDigestPerPage == 4) || (vcx_subDigestPerPage == 9));

    keepVideoType = 0xe0;	/* We only want E0 data.		*/
    initDigest();
    prevDigestTck = digest_track = 1;
    digestAdvanceTrack();
    return (digest_track);
}

/*
 * Called from video decoder to indicate the one digest screen is done.
 */
/* double functions:
   1. luminance level calculation 
   2. signal a subDigest picture has been finished or not finished
 */
/* digestNumMB: counter for tracking how many MB being decoded */
/* digest NumMB used only if orNot==1 */
/* return digestLuminanceLevel */
/* after normalization digestLuminanceLevel is 8-bit signed value
 * ranging from 0x80 to 0x7f
 */
/* assumption:
 * two2one_1st/2nd has been called to put accumulated luminance to port
 */
void signalFinishSubDigest(int orNot)