digest.c

一个两碟控制的VCD的代码,两碟之间的转动及连续播放,已大量生产的CODE.

/* Copyright 1997, ESS Technology, Inc.					*/
/* SCCSID @(#)digest.c	1.77 6/23/98 */

/*
 * $Log$
 */

#ifdef DIGEST

#ifndef CUST71
#define MOVING_DIGEST
#endif

/************************************************************************
 * Header files
 ************************************************************************/
#include "common.h"
#include "timedef.h"
#include "util.h"
#include "vcxi.h"
#include "display.h"
#include "digest.h"
#include "tdm.h"
#include "debug.h"
#include <stdio.h>
#include "vp.h"
#include "xport.h"
#include "dsa.h"
#include "const.h"
#include "play.h"
#ifdef CUST3
#include "custdsa.h"
#endif
#ifdef CUST71
#include "panel.h"
#endif
#ifdef CUST4
#include "dsa4.h"
#endif
#include "custdgt.h"

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

#if (CUST3_63 || CUST71)
#define vcx_digest_audio_duration ZERO_SECOND
#else
#define vcx_digest_audio_duration FOUR_SECOND
#endif /* CUST3_63 */

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

#ifdef CUST3
#define DGST_MAXFRAME 		0
#else /* not CUST3 */
#ifdef CUST4
#define DGST_MAXFRAME 		3
#else
#define DGST_MAXFRAME 		5
#endif /* CUST4 */
#endif /* CUST3 */

#define DGST_FWIDTH 		12	/* digest font width */ 
#define DGST_FHEIGHT 		16 	/* digest font height */
#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

#ifdef CUST3
#define MIN_TRACK_LENGTH	0x0800 	/* 5 sec(end disc) 	  */
					/* + 10 sec + 2sec safety */
#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;
#ifndef S215
PRIVATE 
#endif
unsigned char digest_mode; /* DISC, TRACK or MOTION */

PRIVATE int Vgap;
PRIVATE int Hgap;
PRIVATE int YoffsetEndY;
PRIVATE int XoffsetEndY;
#if (CUST3 && !CUST71)
PRIVATE int pause_sent ;
#endif

#ifdef CUST71
extern int is_audio_mute;
extern int vcx_audio_volume_old; /* 04/28 */
#endif

/************************************************************************
 * 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))
#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;
#if (CUST3 && !CUST71)
    pause_sent = 0;
#endif
    
    digestInited = 1;


#ifndef ZOOM
    done_blank = 0;
    do_blank = 1;	/* Display a tiny screen to blank screen   */
    /* 
     * We'll wait here for up to 1/60th of a second until the 
     * screen is blanked out. During this period of time, I want to
     * continue my communication with DSA and the external
     * microprocessor
     */
    do receive_dsa(); while(!done_blank);
    do_blank = 0;	/* Don't need to blank screen any more */
#else
    DO_blank();
#endif
    
#if 0
    install_filter_coeffs(h_filters[1], h_filters[1]);
#endif

    DISP_change_resolution(704, DISP_scn_height*2);
#ifdef CUST4
    DISP_paint_screen(COLOR_BLACK, 0, DISP_frame);
#else
    DISP_paint_screen(COLOR_BLUE, 0, DISP_frame);
#endif /* CUST4 */
}

/************************************************************************
 * 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;
#if (CUST3 && !CUST3_63)
    int end_disc_flg = 0;
#endif

#ifndef PLAYONLY
    if (digest_mode == DIGEST_TRACK_MODE) {
	start_mmssff = track_start_mmssff;
#if defined(CUST3_63) || defined(CUST3_52) 	
	if (track_delta_time >= 0x00000200)
#endif
	for (i = 1; i < digest_track; i++)
	    start_mmssff = adjCDtime(start_mmssff, track_delta_time, 1);
#ifdef CUST71
	if (track_delta_time >= 0x00002000)
	    start_mmssff = adjCDtime(start_mmssff, 0x500, 1);
	else
            start_mmssff = adjCDtime(start_mmssff, 0x200, 1);
#else
	if (start_mmssff > track_end_mmssff) { 
	    /* start play 3 seconds from end of track */
	    start_mmssff = adjCDtime(track_end_mmssff, 0x300, -1);
	}
#endif

#if defined(CUST3_515)  
	start_mmssff = adjCDtime(start_mmssff, 0x500, 1);
#endif

#if defined(CUST3_63) || defined(CUST3_52) 
	else
	    start_mmssff = adjCDtime(start_mmssff, 0x400, -1);
#endif

    } else if (digest_mode == DIGEST_DISC_MODE) {
	    
#if (CUST3 && !CUST3_63)
	int time_diff;
#endif

	get_track_info(digest_track, &start_mmssff, &end_mmssff, &track_type);
	endCDtime = end_mmssff;
	
#if (CUST3 && !CUST3_63)
	time_diff = adjCDtime(end_mmssff,start_mmssff,-1);
	if (time_diff > MIN_TRACK_LENGTH) {	
	    start_mmssff = adjCDtime(start_mmssff, 0x500, 1);
#ifndef CUST71
	    end_disc_flg = 0;
#endif
	}
#ifdef CUST71
	else
	    start_mmssff = adjCDtime(start_mmssff, 0x200, 1);
#endif
	end_disc_flg = 0;
#endif
    }

    system_reset();
    system_start();
    
#ifdef CUST3_63
    start_mmssff = adjCDtime(start_mmssff, 0x500, 1);
#endif

    /* 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.
     */
#ifdef CUST4 
    digest_out_tmr = glbTimer + FIVE_SECOND; /* Set digest timeout */
#else
    digest_out_tmr = glbTimer + TEN_SECOND; /* Set digest timeout */
#endif 
    playSectors(start_mmssff, 0xe0, 2324);
#endif /* not PLAYONLY */

#if (CUST3 && !CUST3_63)
    if (end_disc_flg) {
        subDigestFinish = 1;
    } else {
        subDigestFinish = 0;
    	digestAudioStart = 0;
    } 
#else
    subDigestFinish = 0;
    digestAudioStart = 0;
#endif
}

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

#ifdef CUST4 /* CUST4 servo gives us physical track */
    last_track = CDinfo.lasttrack - 1;
#else
    last_track = CDinfo.lasttrack;
#endif /*CUST4*/

    digest_mode = DIGEST_DISC_MODE;
#ifdef CUST71
    vcx_audio_volume = 0x1010; /* 04/28 */
#endif
    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;

#ifdef CUST71
    vcx_audio_volume = 0x1010;
#endif
    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);
    endCDtime = track_end_mmssff;
#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;

#ifdef CUST4 /* CUST4 servo gives us physical track */
    last_track = CDinfo.lasttrack - 1;
#else
    last_track = CDinfo.lasttrack;
#endif /*CUST4*/
  
    if ((digest_mode == DIGEST_DISC_MODE) || 
	(digest_mode == DIGEST_TRACK_MODE)) {
	if (subDigestFinish
	    || (digest_out_tmr && (digest_out_tmr < glbTimer))) {

	    if ((!vcx_playaudio_only && !digestAudioStart) 
#ifdef CUST4
		|| PLAY_next_subdigest
#endif
		) {
		vcx_playaudio_only = 1;
		I_am_searching = 0;
		if (!digestDone)
		    dgst_wr_num(digest_track, COLOR_WHITE, 
		                COLOR_BLACK, 8, FILL_E2);
#ifdef CUST4
		if (PLAY_next_subdigest) {
		    PLAY_next_subdigest = 0;
		    digestAudioStart = 0;
		} else 
#endif /* CUST4 */
		{
		    digestAudioStart = glbTimer;
		}
	    } else if ((audioTimeLeft = vcx_digest_audio_duration - 
		(audioElapsed = glbTimer - digestAudioStart)) <= 0) {