digest.c

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

/* Copyright 1997, ESS Technology, Inc.					*/
/* SCCSID @(#)digest.c	4.7 02/25/04 */ 

/*
 * $Log$
 */

#ifdef DIGEST

#define MOVING_DIGEST

/************************************************************************
 * Header files
 ************************************************************************/
#include "vcxi.h"
#include "memmap.h"
#include "timedef.h"
#include "util.h"
#include "echo.h"
#include "display.h"
#include "digest.h"
#include "custdgt.h"
#include "tdm.h"
#include "vcd.h"
#include "dsa.h"
#include "const.h"
#include "vp.h"
#include "debug.h"
#ifdef TWO_FIELDS_OSD
#include "cg.h"
#else
#include "fsosd.h"
#endif


/************************************************************************
 * Compile option
 ************************************************************************/
#define FADING_CONTROL

/************************************************************************
 * Data type define
 ************************************************************************/
typedef struct {
    int start_Y;
    int start_U;
    int start_V;
} DRAM_Addr;

/************************************************************************
 * Some local defines
 ************************************************************************/
#ifdef NEW_DGST_DISP
#define yoffsetGlobal33_Y \
	((DEST_HEIGHT>>2)-VGAP33-((vcx_scn_height==240)?16:24))
#else
#define yoffsetGlobal33_Y \
	((DEST_HEIGHT>>2)-VGAP33)
#endif

#define vcx_digest_audio_duration FOUR_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 DFACTOR 		2  /* decimate factor: hardwired to 2 */
#define D_CHAR_WIDTH 		(OSD_CHAR_WIDTH/DFACTOR)
#define D_CHAR_HEIGHT 		(OSD_CHAR_HEIGHT/DFACTOR)
#define MYDY 			D_CHAR_HEIGHT
#define MYDX 			(D_CHAR_WIDTH>>2)
#define OSD_XPOS(index) 	(xoffset_scratch+(index)*MYDX)

#define DIGEST_DISC_MODE	1
#define DIGEST_TRACK_MODE	2
#define DIGEST_MOTION_MODE	3

#define SOURCE_WIDTH 		((352)>>2)
#define SOURCE_HEIGHT 		vcx_VertSz
#define DEST_HEIGHT		vcx_scn_height

#define DGST_MAXFRAME 		5

#define DGST_FWIDTH 		12	/* digest font width */ 
#ifdef TWO_FIELDS_OSD
#define DGST_FHEIGHT 		CG_FONT_HEIGHT/2 /* digest font ht */
#else
#define DGST_FHEIGHT 		OSD_CHAR_HEIGHT/2 /* digest font ht */
#endif
#ifdef NEW_DGST_DISP
#define DGST_SUBSCRW 		192	/* digest subscreen width */ 
#define DGST_SUBSCRH 		136 	/* digest subscreen height */
#define DGST_FIRST_STARTX \
	((vcx_scn_height==240)? 104:75)	/* digest start x */ 
#define DGST_FIRST_STARTY \
	((vcx_scn_height==240)? 53:45)	/* digest start y */ 
#else
#define DGST_SUBSCRW 		160	/* digest subscreen width */ 
#define DGST_SUBSCRH 		120 	/* digest subscreen height */
#define DGST_FIRST_STARTX 	104	/* digest start x */ 
#define DGST_FIRST_STARTY 	64	/* digest start y */ 
#endif
 
/************************************************************************
 * Private variables
 ************************************************************************/
PRIVATE int xoffsetY;
PRIVATE int yoffsetY;
PRIVATE int frame_count ; 
PRIVATE int digest_out_tmr;		/* for short tracks... 	*/
PRIVATE int digest_track; 		/* current track to be digested */
PRIVATE int track_start_mmssff;
PRIVATE int track_end_mmssff;
PRIVATE int track_delta_time;	/* time diffrence between two segments */
PRIVATE char digestDone=0;
PRIVATE char I_am_searching=0;
PRIVATE char subDigestFinish=0;   /* flag to increment the digest track */
PRIVATE int digestInited;
PRIVATE unsigned char digest_mode; /* DISC, TRACK or MOTION */

PRIVATE int Vgap;
PRIVATE int Hgap;
PRIVATE int YoffsetEndY;
PRIVATE int XoffsetEndY;

/************************************************************************
 * Private function prototype
 ************************************************************************/
PRIVATE void 	initDigest(void); 
PRIVATE void 	digestAdvanceTrack(void);
PRIVATE int 	get_position_index(void);
PRIVATE void 	get_dram_address(DRAM_Addr *, int);

#ifdef NEW_DIGEST_OSD
PRIVATE void    DGST_wr_num(int);
#define dgst_wr_num(a,b,c,d,e) DGST_wr_num((a))
PRIVATE void    DGST_OSD_clear(void);
#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

/************************************************************************
 * Digest initialization
 ************************************************************************/
PRIVATE void initDigest()
{
    digestDone = 0;
    frame_count = 0;
    vcx_digest = 1;
    I_am_searching = 1;
    vcx_playaudio_only = 0;
    subDigestFinish = 0;    
    digestInited = 1;
#ifdef KARASC
    KSC_mode = 0;
#endif


    DISP_do_blank(); /* then do DISP_END_DO_BLANK to bring back screen */    
#if 0
    install_filter_coeffs(h_filters[1], h_filters[1]);
#endif

    DISP_change_resolution(704, DISP_scn_height*2);
    DISP_paint_screen(COLOR_BLUE, 0, DISP_frame);
    DISP_END_DO_BLANK;
}

/************************************************************************
 * Global function. A position index is returned to display a digest 
 * sub-picture.
 ************************************************************************/
PRIVATE int get_position_index(void)
{
    int num_of_windows = num_of_digest_windows;
    int track_index = (digest_track+(num_of_windows-1)) % num_of_windows;

#ifdef MOVING_DIGEST
    track_index = 4;
#endif
    
    return(digest_window[track_index]);
}

/************************************************************************
 * Global function. To setup the display location of the current digest
 * frame in E2 display memory.
 ************************************************************************/
void setupSubDigestScreen()
{
#if 1
    int index = get_position_index();
#else
    int index = (digest_track+(vcx_subDigestPerPage-1)) % vcx_subDigestPerPage;
#endif    

    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 to the next track.
 * For disc mode:  track means the next physical track.
 * For track mode: track means the next part of material in the same 
 *		   physical track.
 ************************************************************************/
PRIVATE void digestAdvanceTrack() 
{
    int start_mmssff;
    int end_mmssff;
    int i;
    unsigned char track_type;


#ifndef PLAYONLY
    if (digest_mode == DIGEST_TRACK_MODE) {
	start_mmssff = track_start_mmssff;
	for (i = 1; i < digest_track; i++)
	    start_mmssff = adjCDtime(start_mmssff, track_delta_time, 1);
	if (start_mmssff > track_end_mmssff) { 
	    /* start play 3 seconds from end of track */
	    start_mmssff = adjCDtime(track_end_mmssff, 0x300, -1);
	}

    } else if (digest_mode == DIGEST_DISC_MODE) {
	get_track_info(digest_track, &start_mmssff, &end_mmssff, &track_type);
	TDM_isCDDA = (track_type == AUDIO_TRACK) ? 1 : 0;

	endCDtime = end_mmssff;	
	second_endCDtime = xMAX_CDTIME;
    }

    system_reset();
    system_start();
    

    /* In track digest, for tracks with low I-frame count (particularly tracks
     * less than 9 seconds long), digest can hang waiting for enough I-frames
     * (DGST_MAXFRAME) to be decoded..so we'll use a timer to timeout in 
     * those cases.
     */
    digest_out_tmr = glbTimer + TEN_SECOND; /* Set digest timeout */
    if (TDM_isCDDA) {
	if (!playCDDA(start_mmssff, start_mmssff, end_mmssff)) {
	    subDigestFinish = 1;
	    return;
	}
    } else {
	playSectors(start_mmssff, 0xe0, 2324);
    }
#endif /* not PLAYONLY */

    subDigestFinish = 0;
    digestAudioStart = 0;
}

/************************************************************************
 * Global function. Disc digest entry point.
 ************************************************************************/
int digestPage(int next) 
{ 
    int track, last_track;

    last_track = CDinfo.lasttrack;
    digest_mode = DIGEST_DISC_MODE;
    initDigest();

#ifndef PLAYONLY
    track =  (next>=0)? last_track: CDinfo.firsttrack;

    if ((next*(digest_track =
	     (((digest_track-1)/vcx_subDigestPerPage+next)*
	      vcx_subDigestPerPage+1))) > (next*track)) {
	digest_track =
	    (next>=0)?((track-1)/vcx_subDigestPerPage)*
		vcx_subDigestPerPage+1:track;
    }
#else
    digest_track = 1;
#endif

    digestAdvanceTrack();

    return(digest_track);
}

/************************************************************************
 * Global function. Track digest entry point.
 ************************************************************************/
int digestTrack(int track) 
{ 
    unsigned char  track_type;


    initDigest();

    /* check the track is a valid one ?? */

    /* get the track info */
#ifndef PLAYONLY
    get_track_info(track, &track_start_mmssff, &track_end_mmssff, &track_type);
    TDM_isCDDA = (track_type == AUDIO_TRACK) ? 1 : 0;

    endCDtime = track_end_mmssff;
    second_endCDtime = xMAX_CDTIME;
#endif
    digest_track = 1;
    digest_mode = DIGEST_TRACK_MODE;

#ifndef PLAYONLY
    /* calculate the delta time */
    track_delta_time = deltaCDtime(track_end_mmssff, track_start_mmssff);
#endif

    digestAdvanceTrack();

    return(digest_track);
}

/************************************************************************
 * Global function. When video is doen, play a bit audio with fading
 * control. Also to determine when to stop digest or advance to next 
 * digest track.
 ************************************************************************/
void decideDigestVideoOrAudio()
{
    int audioTimeLeft;
    int audioElapsed;
    int last_track;

    last_track = CDinfo.lasttrack;
    if ((digest_mode == DIGEST_DISC_MODE) || 
	(digest_mode == DIGEST_TRACK_MODE)) {
	if (subDigestFinish
	    || (digest_out_tmr < glbTimer)) {

	    if ((!vcx_playaudio_only && !digestAudioStart)) {
		vcx_playaudio_only = 1;
		I_am_searching = 0;
		if (!digestDone)
		    dgst_wr_num(digest_track, COLOR_WHITE, 
		                COLOR_BLACK, 8, FILL_E2);

		{
		    digestAudioStart = glbTimer;
		}
	    } else if ((audioTimeLeft = vcx_digest_audio_duration - 
		(audioElapsed = glbTimer - digestAudioStart)) <= 0) { 
		vcx_playaudio_only = 0;
		I_am_searching = 1;
		vcx_fade_audio_volume = 0x8080;	/* No longer fading */
	    }
#ifdef FADING_CONTROL
	    else if (audioTimeLeft < (1<<7)) {
		vcx_fade_audio_volume =
			((vcx_audio_volume & 0xff) * audioTimeLeft) >> 7;
		vcx_fade_audio_volume += vcx_fade_audio_volume << 8;
	    } else
		vcx_fade_audio_volume = 0x8080;
#endif	/* FADING_CONTROL */

	    if (I_am_searching
		/*|| (digest_out_tmr && (digest_out_tmr < glbTimer))*/) {
#ifndef PLAYONLY
		if (digest_out_tmr) {
		    digest_out_tmr = xINFINITY;
		    subDigestFinish = 1; /* Set to paint number */
		    frame_count = 0;	 /* reset frame count */
		}

		if (((digest_track + (vcx_subDigestPerPage-1)) % 
		     vcx_subDigestPerPage) >= (vcx_subDigestPerPage-1) ||
		    ((digest_mode == DIGEST_DISC_MODE) && 
		     (digest_track >= last_track)))
		{
		    extern void turn_off_data();
		    if (!digestDone) {
			digestDone = 1;
			digestAudioStart = 0;