buffer.h

一个不错的硬盘播放器程序,包含VFD显示程序,红外线遥控程序,硬盘读写程序,及解码程序等.

/* Copyright 1996, ESS Technology, Inc.					*/
/* SCCSID @(#)buffer.h	1.66 2/11/98 */

/*
 * $Log$
 */

#ifndef __BUFFER_H__
#define __BUFFER_H__

#include "common.h"

#ifdef SUB_PICTURE
#include "spu/spu.h"
#endif

/******************************************************************************

 Audio and Video bitstream buffer in DRAM. All units in dword.

 ******************************************************************************/

#ifdef MPEG1
#ifdef SVCD
#define ADAM		128
#define MPEG_VBV_size	(3*47*8*ADAM/4)
#define ABV_size	(2*11*ADAM)
#define MPEG_VBV_start  210032	
#define ABV_start       2300	
#else
#define ADAM		128
#define MPEG_VBV_size	(47*8*ADAM/4)
#define ABV_size	(11*ADAM)
#define MPEG_VBV_start	(3708+ADJUST_4_LINE)
#define ABV_start	(2300+ADJUST_4_LINE)
#endif
#else
#define ADAM		127
#define MPEG_VBV_start	(0x46800/4)
#define MPEG_VBV_size	(300*8*ADAM/4)
#ifdef SUB_PICTURE
#if SP_4_BITMODE
/* 4 bit mode */
/* old */
#define ABV_start       (0x2b348/4)
#define ABV_size        (ADAM*840/4)
#if 0
/* new */
#define ABV_start       (0x68/4)
#define ABV_size        (ADAM*872/4)
#endif
#else
/* 8 bit mode */
#define ABV_start       (0x5c00/4)
#define ABV_size        (ADAM*2048/4)
#endif
#else
#define ABV_start	(0x91800/4)
#define ABV_size	(10*8*ADAM/4)
#endif
#endif
#define MPEG_VBV_end		(VBV_start + VBV_size)
#define ABV_end		(ABV_start + ABV_size)

GBLDEF(int VBV_start, MPEG_VBV_start);
GBLDEF(int VBV_end, 0);
GBLDEF(int VBV_size, MPEG_VBV_size);
/******************************************************************************
 Number of dwords we read/write to the buffer with each DMA. Max 512.
 ******************************************************************************/
#define VBV_read	(2*ADAM)
#define VBV_write	(2*ADAM)
#define ABV_read	ADAM
#define ABV_write	ADAM

/******************************************************************************
 R/W pointers and transfer status flags. "filling" means xport buscon is
 running so buffer is being filled. "draining" means huffdec buscon is
 running so buffer is being drained.
 ******************************************************************************/
GBLDEF_0 (int VBV_wrptr, 0);
GBLDEF_0 (int VBV_rdptr, 0);
GBLDEF (int ABV_wrptr, ABV_start);
GBLDEF (int ABV_rdptr, ABV_start);
GBLDEF_0 (int VBV_trigger, 0);
GBLDEF_0 (int ABV_wrptr_save, 0);
GBLDEF_0 (int BUF_ABV_overflow, 0);

GBLDEF_0 (int ABV_filling,  0);
GBLDEF_0 (int VBV_filling,  0);

GBLDEF_0 (int ABV_draining, 0);
GBLDEF_0 (int VBV_draining, 0);

GBLDEF (int VBV_alarm, 1024);	/* VBV space threshold when alarm goes off */

GBLDEF (int PCM_starved, 1);
GBLDEF (int PCM_fake_data, 0);
#ifdef WATCHDOG
GBLDEF_0 (int VBV_ABV_xport_xfer_count, 0);
GBLDEF_0 (int VBV_ABV_huffman_xfer_count, 0);
#endif

/******************************************************************************
 Some macros for internal use.
 ******************************************************************************/
#define BUF_distance(front_ptr, back_ptr, val, buf_size) do { \
    (val) = (front_ptr) - (back_ptr); \
    if (val < 0) val += buf_size; \
} while (0)

#define BUF_advance_ptr(ptr, ndword, buf) do {\
    (ptr) += (ndword); \
    if ((ptr) >= cat2(buf,_end)) (ptr) -= cat2(buf,_size); \
} while (0)

#define BUF_retreat_ptr(ptr, ndword, buf) do {\
    (ptr) -= (ndword); \
    if ((ptr) < cat2(buf,_start)) (ptr) += cat2(buf,_size); \
} while (0)

/******************************************************************************
 Occupancy in system buffer. 0 means empty.
 ******************************************************************************/
#define VBV_update_occupancy(val) \
    BUF_distance(VBV_wrptr, VBV_rdptr, val, VBV_size)

#define ABV_update_occupancy(val) \
    BUF_distance(ABV_wrptr, ABV_rdptr, val, ABV_size)

/******************************************************************************
 Space in system buffer.
 ******************************************************************************/
#define VBV_update_space(val) do {	\
    val = VBV_rdptr - VBV_wrptr;	\
    if (val <= 0) val += VBV_size;	\
} while (0)

#define ABV_update_space(val) do {	\
    val = ABV_rdptr - ABV_wrptr;	\
    if (val <= 0) val += ABV_size;	\
} while (0)

/******************************************************************************
 The PCM buffer followed by the zero buffer.
 The zero buffer should be no more than 256 dwords in the MPEG2 layout,
 and 252 dwords in the MPEG1 layout.

 PCM_size must be a multiple of 384 for MUSICAM, and a multiple of 256 for AC3.
 ******************************************************************************/
#ifdef MPEG1
#ifdef ECHO
#define PCM_start       126032
#define PCM_size        4992	/* Must be multiple of 384 */
#else  /* No echo */
#ifdef SVCD
#define PCM_start       5116 
#else
#define PCM_start       125264
#endif
#define PCM_size        5760	/* Must be multiple of 384 */
#endif /* end of #ifdef ECHO */
#define PCM_zero_size   48	/* The first 4 DW are used for "do blank" and
				   the rest 44 DW are used for spatializer */
#else
#define PCM_start       773632
#define PCM_size        2*6144	/* Must be multiple of 256 and 384 */
#define PCM_zero_size   128
#endif

#define PCM_end         (PCM_start + PCM_size)

#define PCM_zero_start  PCM_end
#define PCM_zero_end    (PCM_zero_start + PCM_zero_size)

/******************************************************************************
 R/W pointers.
 PCM_raw_wrptr is where decoded audio goes.
 Data is taken from PCM_rdptr to be sent to the audio DAC. 
 Karaoke takes input from PCM_raw_rdptr. Results go to PCM_wrptr.
 If there is no karaoke PCM_raw_wrptr and PCM_wrptr are the same, and
 PCM_raw_rdptr doesn't exist.
 ******************************************************************************/
GBLDEF (int PCM_raw_wrptr, PCM_start);
GBLDEF (int PCM_rdptr, PCM_start);
#ifdef KARAOKE
GBLDEF (int PCM_wrptr, PCM_start);
GBLDEF (int PCM_raw_rdptr, PCM_start);
#ifdef SPATIAL
GBLDEF (int SPA_wrptr, PCM_start);
#endif
#else
#define PCM_wrptr PCM_raw_wrptr
#undef PCM_raw_rdptr
#endif

/******************************************************************************
 Initialise all PCM pointers.
 ******************************************************************************/
#ifdef KARAOKE
#ifdef SPATIAL
#define PCM_init_pointers() do {		\
    PCM_rdptr = PCM_raw_wrptr = PCM_start;	\
    PCM_wrptr = PCM_raw_rdptr = PCM_start;	\
    SPA_wrptr = PCM_wrptr;                      \
} while (0)
#else
#define PCM_init_pointers() do {		\
    PCM_rdptr = PCM_raw_wrptr = PCM_start;	\
    PCM_wrptr = PCM_raw_rdptr = PCM_start;	\
} while (0)
#endif
#else
#define PCM_init_pointers() PCM_rdptr = PCM_raw_wrptr = PCM_start
#endif

/******************************************************************************
 Occupancy in PCM buffer. SPA_wrptr == PCM_rdptr means empty.
 ******************************************************************************/
#if defined(KARAOKE) && defined(SPATIAL)
#define PCM_update_occupancy(val) \
    BUF_distance(SPA_wrptr, PCM_rdptr, val, PCM_size)
#else
#define PCM_update_occupancy(val) \
    BUF_distance(PCM_wrptr, PCM_rdptr, val, PCM_size)
#endif

#ifdef KARAOKE
#define PCM_update_raw_occupancy(val) \
    BUF_distance(PCM_raw_wrptr, PCM_raw_rdptr, val, PCM_size)
#else
#define PCM_update_raw_occupancy(val) \
    BUF_distance(PCM_raw_wrptr, PCM_rdptr, val, PCM_size)
#endif

/******************************************************************************
 Room in PCM buffer for karaoke.
 ******************************************************************************/
#ifdef KARAOKE

#define PCM_update_kra_output_room(val) \
    BUF_distance(PCM_raw_rdptr, PCM_wrptr, val, PCM_size)

#define PCM_update_kra_input_available(val) \
    BUF_distance(PCM_raw_wrptr, PCM_raw_rdptr, val, PCM_size)

#endif

/******************************************************************************
 Room in PCM buffer for audio decoding.
 PCM_raw_wrptr == PCM_rdptr means buffer empty.
 ******************************************************************************/
#define PCM_update_space(val) do { 	\
    val = PCM_rdptr - PCM_raw_wrptr;	\
    if (val <= 0) val += PCM_size;	\
} while (0);

/******************************************************************************
 Some pointer advancement macros. These all assume that the buffer size
 is an integer multiple of the xfer size.
 ******************************************************************************/
#define nice_ptr_advance(A, rw, n) do {	\
    A##_##rw += n;			\
    if (A##_##rw == A##_end)		\
	A##_##rw = A##_start;		\
} while (0)

#define PCM_raw_wrptr_advance(n) nice_ptr_advance(PCM, raw_wrptr, n)
#define PCM_rdptr_advance(n) nice_ptr_advance(PCM, rdptr, n)
#define VBV_wrptr_advance(n) nice_ptr_advance(VBV, wrptr, n)
#define VBV_rdptr_advance(n) nice_ptr_advance(VBV, rdptr, n)
#define ABV_wrptr_advance(n) nice_ptr_advance(ABV, wrptr, n)
#define ABV_rdptr_advance(n) nice_ptr_advance(ABV, rdptr, n)

/******************************************************************************
 Start d2a buscon.
 ******************************************************************************/
#ifdef ZERO_BUFFER
#define PCM_start_take_out() do {			\
    assert(!(mvd[gate_d2a_ff_status]&0xff));		\
    PCM_take_out();					\
    buscon_irq_enable(buscon_d2a_runbit);		\
} while (0);
#else
#define PCM_start_take_out() do {			\
    assert(!(mvd[gate_d2a_ff_status]&0xff));		\
    PCM_take_out();					\
} while (0);
#endif
/******************************************************************************
 Clear buffers.
 ******************************************************************************/#define PCM_clear_buffer() dram_clear(PCM_start, PCM_size)
#define PCM_clear_zero_buffer() dram_clear(PCM_zero_start, PCM_zero_size)

/******************************************************************************

 Exported functions.

 ******************************************************************************/
void VBV_start_filling(void);
void ABV_start_filling(void);
void VBV_stop_filling(void);
void ABV_stop_filling(void);
void VBV_ABV_stop_filling(void);
void VBV_ABV_stop_draining(void);
void VBV_ABV_set_parameters(int);
void PCM_init(void);
void PCM_take_out(void);
void PCM_back_track(void);
void BUSCON_interrupt_service(void);

#endif /* __BUFFER_H__ */