buffer.h

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

/* Copyright 1996, ESS Technology, Inc.					*/
/* SCCSID @(#)buffer.h	4.10 01/14/05 */

/*
 * $Log$
 */

#ifndef __BUFFER_H__
#define __BUFFER_H__

#include "common.h"


#ifdef ANTI_SHOCK
#define ABV_CHUNK	MP3_SECTOR_SIZE	/* 4*ABV_write */
#else
#define ABV_CHUNK	ABV_write
#endif

/* macros for getSectors() data */
#define GETSECTOR_DATA_RDPTR	VBV_rdptr
#define GETSECTOR_DATA_START	VBV_start

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


/******************************************************************************
 * for scheduler and standalone audio decoder 
 *****************************************************************************/
#define PCM_PER_DECODE (384*2) 
extern void AUD_service(void);

/******************************************************************************
 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.
 ******************************************************************************/
GBLDEF0	(int VBV_wrptr);
GBLDEF0 (int VBV_rdptr);
#if (defined(MP3) || defined(AVI_DEC))
GBLDEF0 (int ABV_wrptr);
GBLDEF0 (int ABV_rdptr);
GBLDEF0 (int ABV_byte_start);
GBLDEF0 (int ABV_byte_end);
GBLDEF0 (int ABV_byte_size);
GBLDEF0 (int ABV_byte_rdptr);
GBLDEF0 (int ABV_byte_wrptr);
#else
GBLDEF (int ABV_wrptr, VCD_ABV_start);
GBLDEF (int ABV_rdptr, VCD_ABV_start);
#endif

#ifdef AVI_DEC
GBLDEF	(int WAV_wrptr, WAV_start);
GBLDEF	(int WAV_rdptr, WAV_start);
GBLDEF0 (int WAV_byte_start);
GBLDEF0 (int WAV_byte_end);
GBLDEF0 (int WAV_byte_size);
GBLDEF0 (int WAV_byte_rdptr);
GBLDEF0 (int WAV_byte_wrptr);

GBLDEF0 (int VBV_byte_start);
GBLDEF0 (int VBV_byte_end);
GBLDEF0 (int VBV_byte_size);
GBLDEF0 (int VBV_byte_rdptr);
GBLDEF0 (int VBV_byte_wrptr);
#endif

#ifndef VCDLC /* ANTI_SHOCK only for 2MB code */
#ifdef ANTI_SHOCK
GBLDEF0 (unsigned int ABV_data_save[2]);
GBLDEF0 (int ABV_gdptr);
/* for CDDA ESP */
GBLDEF0 (int AS_ABV_rdptr);
GBLDEF0 (int AS_ABV_wrptr);
GBLDEF0 (int XPORT_data_end);
#endif /* ANTI_SHOCK */

GBLDEF0 (int ABV_set_good); /* ANTI_SHOCK..enabled for servos */
#endif /* !VCDLC */

GBLDEF0 (int ABV_xfer_flag);
GBLDEF0 (int VBV_trigger);
GBLDEF0 (int ABV_wrptr_save);
GBLDEF0 (int BUF_ABV_overflow);

GBLDEF0 (int ABV_filling);
GBLDEF0 (int VBV_filling);

GBLDEF0 (int ABV_draining);
GBLDEF0 (int VBV_draining);

GBLDEF	(int VBV_alarm, 1024);	/* VBV space threshold when alarm goes off */
GBLDEF0 (volatile int VBV_wrap_count);	/* counts of VBV_rdptr wraps */
GBLDEF0 (int VBV_trigger_ref);	/* VBV_wrap_count at VBV_trigger */
GBLDEF0 (int VBV_trigger_check); /* compare VBV_rdptr with VBV_trigger? */

GBLDEF (int PCM_starved, 1);
GBLDEF (int PCM_fake_data, 0);
#ifdef WATCHDOG
GBLDEF0 (int VBV_ABV_xport_xfer_count);
GBLDEF0 (int VBV_ABV_huffman_xfer_count);
#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)

#if (defined(MP3) || defined(AVI_DEC))
#define ABV_byte_update_occupancy(val) do { \
    ABV_byte_wrptr = dram(ABV_wrptr); \
    BUF_distance(ABV_byte_wrptr, ABV_byte_rdptr, val, ABV_byte_size); \
} while(0)
#endif

#ifdef AVI_DEC
#define VBV_byte_update_occupancy(val) do { \
    BUF_distance(VBV_byte_wrptr, VBV_byte_rdptr, val, VBV_byte_size); \
} while(0)

#define WAV_byte_update_occupancy(val) do { \
    BUF_distance(WAV_byte_wrptr, WAV_byte_rdptr, val, WAV_byte_size); \
} while(0)
#endif

/* ANTI_SHOCK */
#define ABV_update_gd2wr(val) \
    BUF_distance(ABV_wrptr, ABV_gdptr, val, ABV_size); \

#define AS_ABV_update_occupancy(val) \
    BUF_distance(AS_ABV_wrptr, AS_ABV_rdptr, val, AS_ABV_size)

#define AS_ABV_update_space(val) do {	\
    val = AS_ABV_rdptr - AS_ABV_wrptr;	\
    if (val <= 0) val += AS_ABV_size;	\
} while (0)
/* ANTI_SHOCK */

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

/*****************************************************************************
 Reset the VBV to its initial state.
 *****************************************************************************/
#define VBV_reset() do {                        \
    VBV_rdptr = VBV_wrptr = VBV_start;          \
    VBV_fullness = 0;                           \
} while (0)


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

/* KARASC */
GBLDEF (int KFREF_wrptr, KFREF_start);
GBLDEF (int KFREF_rdptr, KFREF_start);

/******************************************************************************
 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 nice_ptr_retreat(A, rw, n) do {	\
    if (A##_##rw == A##_start)		\
	A##_##rw = A##_end;		\
    A##_##rw -= n;			\
} 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)

/* ANTI_SHOCK */
#define ABV_gdptr_advance(n) nice_ptr_advance(ABV, gdptr, n)
#define ABV_wrptr_retreat(n) nice_ptr_retreat(ABV, wrptr, n)
#define ABV_rdptr_retreat(n) nice_ptr_retreat(ABV, rdptr, n)

#define AS_ABV_wrptr_advance(n) nice_ptr_advance(AS_ABV, wrptr, n)
#define AS_ABV_rdptr_advance(n) nice_ptr_advance(AS_ABV, rdptr, n)
/* ANTI_SHOCK */

/******************************************************************************
 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_draining(void);
void VBV_stop_draining(void);
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 VBV_ABV_default(void);
void PCM_init(void);
void PCM_take_out(void);
void PCM_back_track(void);
void BUSCON_interrupt_service(void);
#ifdef CDG
void Is_xporta_isr();
#endif
#ifdef PRE_EMPHASIS
void CDDA_init(void);
#endif

#endif /* __BUFFER_H__ */