buffer.c

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

/* SCCSID @(#)buffer.c	1.6 12/3/97 */

/*
 * $Log$
 */


#include "../common.h"
#include "../debug.h"
#include "util.h"
#include "../dsc.h"
#include "../vp.h"
#include "../tdm.h"
#include "../sysinfo.h"
#include "display.h"
#include "low.h"

#define MPEG1

#include "buffer.h"
#include "ucode30.map"

/****************************************************************************
 Local defines.
 ****************************************************************************/
#define	done_but_needed(ch) \
    ((!buscon_is_running(ch))&&(mask & buscon_##ch##_runbit))

/****************************************************************************
 Debugging.
 ****************************************************************************/

#define PRINTF(a)
/****************************************************************************
 Local function prototypes.
 ****************************************************************************/

/****************************************************************************
 Local variables.
 ****************************************************************************/
#ifdef MVD_BOARD
static int is_TDM;
#else
#define is_TDM	1
#endif

#ifdef CD_LOAD

/******************************************************************************
 If there's enough room in DRAM initiate a xport buscon to sys buff. 
 rdptr == wrptr means buffer empty. In the case of TDM we do it anyway.
 ******************************************************************************/
#ifdef XFER_USE_MACRO

#define xportv_xfer_TDM()	do {					\
    int space = VBV_rdptr - VBV_wrptr;					\
    if (space <= 0) space += VBV_size;				  	\
    if (space <= VBV_write) {						\
	KEYDEBUGINC(1, VBV_overflow);					\
	DBG_log_error(99, 1, space, VID_decoding_in_progress, 0, 0);	\
	VBV_rdptr = VBV_wrptr;						\
    }									\
    buscon_xfer(xportv, BDMA_USEDX, VBV_wrptr, VBV_write, 1);		\
} while (0)

#ifdef MVD_BOARD
#define xportv_xfer_non_TDM()	do {					\
    int space = VBV_rdptr - VBV_wrptr;					\
    if (space <= 0) space += VBV_size;				  	\
    if (space > VBV_write) {						\
	buscon_xfer(xportv, BDMA_USEDX, VBV_wrptr, VBV_write, 1);	\
	VBV_filling = 1;						\
    } else {								\
	VBV_filling = 0;						\
    }									\
  } while (0)

#endif /* MVD_BOARD */

#else /* XFER_USE_MACRO */

#endif

#define xportv_xfer()	do {		\
    if (is_TDM) xportv_xfer_TDM();	\
    else xportv_xfer_non_TDM();		\
} while (0);

#define xporta_xfer()	do {		\
    if (is_TDM) xporta_xfer_TDM();	\
    else xporta_xfer_non_TDM();		\
} while (0);

/******************************************************************************
 Just finished a xport buscon to sys buff. Update sys buff write ptr.
 If xfer to huffdec is not running, start a new one.
 ******************************************************************************/
#ifdef WATCHDOG
#define xportv_xfer_end()	do {				\
    VBV_wrptr += VBV_write;					\
    VBV_xport_xfer_count++;					\
    if (VBV_wrptr == VBV_end) VBV_wrptr = VBV_start;		\
    DBG_log_buffer(20, VBV_write, VBV_wrptr, VBV_rdptr, 0, 0);	\
} while (0)

#else
#define xportv_xfer_end()	do {				\
    VBV_wrptr += VBV_write;					\
    if (VBV_wrptr == VBV_end) VBV_wrptr = VBV_start;		\
    DBG_log_buffer(20, VBV_write, VBV_wrptr, VBV_rdptr, 0, 0);	\
} while (0)

#endif


#endif /* CD_LOAD */

#ifdef MIDI
/****************************************************************************
 Kill the d2a buscon. Then we reset the d2a gateway fifo.
 ****************************************************************************/
void	PCM_stop_take_out(void)
{
    buscon_zap(d2a);
    gbl_gate_fiforeset |= 0x100;
    mvd[gate_fiforeset] = gbl_gate_fiforeset;
    gbl_gate_fiforeset &= ~0x100;
    mvd[gate_fiforeset] = gbl_gate_fiforeset;
    PCM_starved = 1;
}

/****************************************************************************
 Initialise the PCM and the zero buffer.
 ****************************************************************************/
void	PCM_init()
{
    PCM_clear_buffer();
    PCM_clear_zero_buffer();
    PCM_rdptr = PCM_start;
    PCM_wrptr = PCM_start;
}
#endif /* MIDI */

/************************************************************************
 Buscon interrupt service.
 ************************************************************************/
void EVD_BUSCON_interrupt_service(void)
{
    int mask;
    mask = mvd[buscon_dma_irqmasks];


    if (done_but_needed(d2a)) {
#ifdef AUD_WAV
        d2a_interrupt_service();
#endif
#ifdef MIDI
	PCM_take_out();
#endif
    }
#ifdef CD_LOAD
    if (done_but_needed(xportv)) {
	xportv_xfer_end();
	xportv_xfer();
	if (!VBV_filling) buscon_irq_disable(xportv);
#ifdef HRES
	if (HRES_pic) DispYUV();
#endif
    }
#endif
}


#if (CD_LOAD && HRES)
static int Y_cnt = 0;
static int UV_cnt = 0;
static int Yfilling = 1;
static int first_sec = 0;
static int Ytmp_wrptr;
static int UVtmp_wrptr;

#define YLEN  2176
#define UVLEN 1088

void DispYUV(void)
{
    int buffer_size;
    int total = 0;
    int left;
    int i;

#if 0
    if (first_sec == 1){
	first_sec ++;
	VBV_rdptr += VBV_write;
	return;
    }
    if (first_sec){
	first_sec = 0;
	total = 16;
	VBV_rdptr += 16;
    }
#endif
    do {
	left = VBV_write-total;
        if (Yfilling){
            if (Y_cnt < YLEN){
                if ((Y_cnt+left) >= YLEN){
                    buffer_size = YLEN - Y_cnt;
                    Y_cnt = YLEN;
                }
                else {
                    buffer_size = left;
                    Y_cnt += left;
                }
            }
        }
        else{
            if (UV_cnt < UVLEN){
                if ((UV_cnt+left) >= UVLEN){
                    buffer_size = UVLEN - UV_cnt;
                    UV_cnt = UVLEN;
                }
                else {
                    buffer_size = left;
                    UV_cnt += left;
                } 
            } 
        }

	total += buffer_size;
 
        VP_xfer(NCMDQ_VP_xfer,VPCMD_W_DP,0,0,VBV_rdptr,buffer_size,1);
        VP_xfer_wait();
        VBV_rdptr += buffer_size;
        if (VBV_rdptr == VBV_end) VBV_rdptr = VBV_start;
 
        if (Yfilling){
	    if (vcx_scn_height == 288){
                VP_endio(NCMDQ_VP_endio);
                VP_xfer_bf(NCMDQ_VP_xfer,VPCMD_R_DP,0,0,Y_wrptr,buffer_size,1);
            	Y_wrptr += (buffer_size - (buffer_size>>2));
	    }
	    else{
            	VP_xfer(NCMDQ_VP_xfer,VPCMD_R_DP,0,0,Ytmp_wrptr,buffer_size,1);
            	Ytmp_wrptr += buffer_size;
	    }
            VP_xfer_wait();
        }
        if (!Yfilling){
            if (vcx_scn_height == 288){ 
                VP_endio(NCMDQ_VP_endio);
                VP_xfer_bf(NCMDQ_VP_xfer,VPCMD_R_DP,0,0,UV_wrptr,buffer_size,1);
            	UV_wrptr += (buffer_size-(buffer_size>>2));
	    }
	    else{
            	VP_xfer(NCMDQ_VP_xfer,VPCMD_R_DP,0,0,UVtmp_wrptr,buffer_size,1);
            	UVtmp_wrptr += buffer_size;
	    }
            VP_xfer_wait();
	    if (UV_wrptr>0x1ff00) UV_wrptr = 0x1ff00;
        }
        if (Y_cnt == YLEN){
            Yfilling = 0;
            Y_cnt = 0;
        }
        if (UV_cnt == UVLEN){
            Yfilling = 1;
            UV_cnt = 0;
	    if (vcx_scn_height == 240) ntsc_vscale();
        }
    }while(total<VBV_write);
}

extern int scale_mb_from_Y, scale_mb_from_UV, scale_mb_to_Y, scale_mb_to_UV;
static int UV_jump=0;
void ntsc_vscale(void)
{
    int i;

    scale_mb_from_Y = YScaleH;
    scale_mb_from_UV = UScaleH;
    scale_mb_to_Y = Y_wrptr;
    scale_mb_to_UV = UV_wrptr;
    Ytmp_wrptr = YScaleH;
    UVtmp_wrptr = UScaleH;
    for (i=0;i<17;i++)
	vscale3();

    Y_wrptr += 1326;
    if (UV_jump)
        UV_wrptr += 714;
    else
	UV_wrptr += 612;
    UV_jump = 1- UV_jump;
}

extern int YFrameAddr;
extern int UFrameAddr;

void Hres_init(void)
{
	int i;

	HRES_pic = 0;
	UV_jump = 0;
	Y_wrptr = (YFrameAddr & 0xffffff)>>2;
	UV_wrptr = (UFrameAddr & 0xffffff)>>2;
	if (vcx_scn_height == 240){
	    Ytmp_wrptr = YScaleH;
	    UVtmp_wrptr = UScaleH;
	    initVscale_Pointer();
	}
	Y_cnt = 0;
	UV_cnt = 0;
	Yfilling = 1;
        XPORT_flushGateway();
	VBV_start = 0x64dc;
	VBV_size = HIGH_RES_VBV_SIZE;
	VBV_wrptr = VBV_rdptr = VBV_start;
	Yfilling = 1;
	HRES_pic = 1;
	first_sec = 1;
}

#endif

void EVD_PCM_clear_zero_buffer(void)
{
    int *p;
    int i;

    p=(int *)dram(PCM_zero_start);
    for (i=0;i<PCM_zero_size;i++) *(p+i)=0;

#if 0
    VP_ucode(NCMDQ_VP_ucode, clearalldp);
    VP_ucode_wait();
    VP_xfer(NCMDQ_VP_xfer, VPCMD_R_DP, 0, 0, PCM_zero_start, PCM_zero_size, 1);
    VP_xfer_wait();
#endif

}

#ifdef MIDI
void    PCM_take_out(void)
{
    int amount_of_pcm_data;

    if (!PCM_starved) { /* Last time we didn't starve. Update read ptr */
        PCM_rdptr += MIX_FIFO_SIZE;
        if (PCM_rdptr >= PCM_end) {
            PCM_rdptr = PCM_start;
        }
    }

    amount_of_pcm_data = PCM_wrptr - PCM_rdptr;
    if (amount_of_pcm_data<0) amount_of_pcm_data += PCM_size;

    if (amount_of_pcm_data >= MIX_FIFO_SIZE) {
        buscon_xfer(d2a, 0, PCM_rdptr, MIX_FIFO_SIZE, 1);
        PCM_starved = 0;
    } else {
        buscon_xfer(d2a, 0, PCM_zero_start, PCM_zero_size, 1);
        if ((mvd[buscon_dma_irqmasks] & 0x1000)==0){
                buscon_irq_enable(d2a);
#ifdef DSC
                DSC_reset_audio();
#endif
        }
        PCM_starved = 1;
    }
    PCM_out();
}


/**************************************************************************
 Clear the entire PCM buffer.
 **************************************************************************/
void PCM_clear_buffer(void)
{
    int *p;
    int i;
    p=(int *)dram(PCM_start);
    for (i=0;i<PCM_size;i++) *(p+i)=0;
}

void PCM_clear_mem(int p,int size)
{
    int i;
    int *pp;
  
#if 0 
    VP_ucode(NCMDQ_VP_ucode, clearalldp);
    VP_ucode_wait();
    for (i=0;i<4;i++)
      VP_xfer(NCMDQ_VP_xfer, VPCMD_R_DP, 0, 0, p+i*sam_size, sam_size, 1);
    VP_xfer_wait();
#else
    pp= (int*)dram(p);
    for (i=0;i<size;i++){
        *(int*)pp=0;
        pp++;
    }
#endif
}
 

#endif /*MIDI*/