digest.c

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

			turn_off_data();	/* Safer than setting TDM_off */
			clear_dec(); /* Reset VBV pointers, since we do
					not need to do any more video
					decoding. */
		    }
		} else
#endif
		{

		    {
#ifdef MOVING_DIGEST
			if (digest_track % vcx_subDigestPerPage) {
			    int tmp = (digest_track - 1)%num_of_digest_windows;
			    DGST_move_window(4, move_window[tmp]);
			}
#endif
			digest_track++;
			digestAdvanceTrack();
		    }
		}
	    }
	}
    } else if ((digest_mode == DIGEST_MOTION_MODE) && subDigestFinish) {
    	dgst_wr_num(digest_track, COLOR_WHITE, COLOR_BLACK, 8, FILL_E2);
    }
}

/************************************************************************
 * Global function. Reset digest related things.
 ************************************************************************/
void resetDigest()
{
    /* reset global variables when we are not in digest mode. */
    vcx_digest = 0;
    I_am_searching = 0;
    vcx_playaudio_only = 0;
    digestAudioStart = 0;
    subDigestFinish = 0;
    digest_track = 0; /* reset the starting digest track number */

    if (digestInited) {
	digestInited = 0;
	vcx_fade_audio_volume = 0x8080;
    }

    system_reset();

    DISP_do_blank(); /* then do DISP_END_DO_BLANK to bring back screen */

    DISP_change_resolution(vcx_HorizSz, vcx_VertSz);
#if 0
    install_filter_coeffs(h_filters[0], h_filters[1]);
#endif
    DISP_END_DO_BLANK;
}

/************************************************************************
 * Global function. One I frame has been digested, reset the frame_count. 
 ************************************************************************/
void signalFinishSubDigest(int orNot)
{
    if (orNot) { 
        /* normalize it */ 
        frame_count++; 
    } 

    subDigestFinish = (orNot && (frame_count > DGST_MAXFRAME)); 

    if (subDigestFinish) {
	frame_count=0;
    }
}

/************************************************************************
 * Global function. Check if the macroblock is out of the display range. 
 ************************************************************************/
int checkSubDigestRange(int MBRow, int MBColumn)
{
    int tmpMBRow;
    int tmpMBColumn;

    tmpMBRow = MBRow;
    tmpMBColumn = MBColumn;

    if (vcx_subDigestPerPage == 9) {
	tmpMBRow>>=1;
	tmpMBColumn>>=1;
    }

    /* Check if the macro block is in the subdigest picture range. */
    return((tmpMBColumn>=Hgap)                        
	   && tmpMBColumn <(Hgap+XoffsetEndY)                     
	   && (tmpMBRow>=Vgap)                                      
	   && tmpMBRow < (Vgap+YoffsetEndY)                       
	   );
}

/************************************************************************
 * Global function. Tell the play control what the current track is. 
 ************************************************************************/
int current_digest_track()
{
    return (digest_track);
}

/************************************************************************
 * Digest OSD.
 * Write a number at special position, number can not be larger than 99.
 ************************************************************************/
#ifndef USE_DGS_FONT 
PRIVATE void DGST_font(int num, int *addr) 
{
	int i,j, tmp, ctmp, *dest;
    unsigned char scratch_buf[192];/* To store decompressed dat	*/
    unsigned char *srcptr;

#ifdef USE_VWCOMP
	ctmp = T_digit2ascii[num] - FONT_START;
    /* Decompress 24B into scratch_buf */
    newicon_decomp(scratch_buf, 
				   T_osd_efonts_comp_font+T_osd_efonts_offset_tbl[ctmp], 
				   T_osd_efonts_code_book,  6,  DGST_FHEIGHT);
    srcptr = scratch_buf;
#else
	ERROR - In DGST_font();
#endif	
	dest = addr;
	for (j=0; j<DGST_FHEIGHT; j++){
		ctmp = 0;
		for (i=0; i<6; i++){
			tmp = *srcptr++;
			ctmp <<= 4;
			ctmp |= ((tmp & 0x30)>>2);
			ctmp |= (tmp & 0x03);
		}
		*dest++ = ctmp;
	}
}
#endif /* !USE_DGS_FONT  */

#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; /* white */
	    case 0x40: *cp = 0x80; break; /* black */
	    case 0x80: *cp = 0xb2; break; /* blue */
	}
	b <<= 2;
	cp++;
    }
    *dw = x;
}

PRIVATE void DGST_overlay(int num, int addr)
{
    int *fp;
    int *dp = (int *)dram(addr);
    int i, j, dw;
    char *cp;
#ifndef USE_DGS_FONT 
	int ibuf[DGST_FHEIGHT];

	DGST_font(num, ibuf);
	fp = ibuf;
#else
	fp = (int *)(T_dgs_font + 16*num);
#endif
	
    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;
    uint num_bcd;

    if (TDM_isCDDA) {
	/* for CDDA, clear digest osd background */
	DGST_OSD_clear();
    }
    dst = DIGEST_OSD_start;
    
    num_bcd = hex2bcd[num]; /* num < 99 */
    if (num > 9) {
	DGST_overlay(num_bcd>>4, dst);
	DGST_overlay(num_bcd&0xf, dst+4);
    } else
    	DGST_overlay(num_bcd&0xf, 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);
}

void DGST_OSD_clear(void)
{
    int *dp = (int *)dram(DIGEST_OSD_start);
    int i, j;

    /* clear background to blue */
    for (j=0;j<(DGST_FHEIGHT*2);j++) { 
        for (i=0;i<4;i++) { 
	    one_byte_becomes_one_dword(0xaa, dp);
	    dp++;
        }
    } 
}
#else	/* NEW_DIGEST_OSD */

/************************************************************************
 * Digest OSD.
 * Write a number at special position, number can not be larger than 99.
 ************************************************************************/
PRIVATE void DGST_wr_num(num, fc, bkc, blend, frame) 
int num, fc, bkc, blend, frame;
{ 
    int offsetX,offsetY; 
    int subnum,dnum;
#if 1
    int index = get_position_index();
#else 
    int index = num - 1;
#endif

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

    if (DISP_scn_height==288) 	/* PAL ??? note:  Y_PAL=Y_NTSC*6/5+4 */ 
	offsetY=DGST_SUBSCRH*6/5*(((index)%9)/3)+DGST_FIRST_STARTY*6/5+8;     
    else			/*NTSC */ 
	offsetY=DGST_SUBSCRH*(((index)%9)/3)+DGST_FIRST_STARTY;        

    offsetX=DGST_FIRST_STARTX+(((index)%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);
} 

/************************************************************************
 * Digest OSD.
 * Write a number at special position, notice: only one digital.           
 ************************************************************************/
PRIVATE void DGST_wr_numxy(num, fc, bkc, blend, frame, x, y) 
int num, 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 MOVING_DIGEST
/************************************************************************
 * Move digest window from "orig" to "dest".
 * Both "orig" and "dest" are digest window index defined in custdgt.h.
 * Return -1 if the input window index is out of range.
 ************************************************************************/
int DGST_move_window(orig, dest)
int orig, dest;
{
    DRAM_Addr from, to, bkgd;
    int i, j, width_Y, height_Y;

    /*
     * Check the input window index.
     */
    if ((orig < 0) || (orig > 8) || (dest < 0) || (dest > 8))
	return (-1);	/* out of index range */

    /*
     * Get the corresponding dram location according to 
     * digest window index.
     */
    get_dram_address(&from, orig);
    get_dram_address(&to, dest);
    
    get_dram_address(&bkgd, -1);	/* get background address */

    width_Y = subDigestXSpacing33;
    height_Y = subDigestYSpacing33;
	    
    /*
     * Copy the corresponding Y, U and V.
     */
    for (i = 0; i < width_Y; i++) {
	for (j = 0; j < height_Y; j++) {
	    int addr = i + j*DMAWIDTH2_E2_UV*2;	

	    /* Y */
	    *(long *) dram(addr + to.start_Y) = 
	    *(long *) dram(addr + from.start_Y);
	    *(long *) dram(addr + from.start_Y) =
	    *(long *) dram(i + bkgd.start_Y);

	    /* U and V */
	    if ((i < width_Y>>1) && (j < height_Y>>1)) {
	    	*(long *) dram(addr + to.start_U) =
	    	*(long *) dram(addr + from.start_U);
	    	*(long *) dram(addr + from.start_U) =
	    	*(long *) dram(i + bkgd.start_U);

	    	*(long *) dram(addr + to.start_V) =
	    	*(long *) dram(addr + from.start_V);
	    	*(long *) dram(addr + from.start_V) =
	    	*(long *) dram(i + bkgd.start_V);
	    }
	}
    }

    return (0);	/* done */
}

/************************************************************************
 * Get the starting dram address of Y, U and V according to digest 
 * window index. Index == -1 means background.
 ************************************************************************/
PRIVATE void get_dram_address(ptr, index)
DRAM_Addr *ptr;
int index;
{
    DISP_Info *dip = DISP_info + 3;	/* e2 frame */
    int x, y, offset, y_offset, uv_offset;
    
    if (index >= 0) {
    	x = xoffset33_Y(index);	/* x coordinate in unit of DWORD */
    	y = yoffset33_Y(index);	/* y coordinate (number of lines) */

    	/*
     	 * For PAL source and NTSC display in digest mode, we cropped
     	 * the first 2 macroblock rows for each digest picture. So we
     	 * have to advance the y coordinate by 16 (32/2 lines) in order
     	 * to get the ture starting dram addresses.
     	 */
    	if (vcx_VertSz > vcx_scn_height) y += 16;
    } else { 	/* background */
	x = xoffset33_Y(1);
	y = yoffset33_Y(1) - 20;
    }

    /*
     * Convert to linear addresses for Y and UV. 
     */
    offset = y * DMAWIDTH2_E2_UV;
    y_offset = x + (offset<<1);
    uv_offset = (x>>1) + offset;

    /*
     * Obtain the starting Y, U and V addresses based on 
     * the addresses in DISP_info for e2 offset by (x,y) 
     * location.
     */
    ptr->start_Y = dip->startY + y_offset;
    ptr->start_U = dip->startU + uv_offset;
    ptr->start_V = dip->startV + uv_offset;
}
#endif	/* MOVING_DIGEST */

#endif /* DIGEST */