mirror of https://github.com/tongzx/nt5src
You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
648 lines
16 KiB
648 lines
16 KiB
//
|
|
// MODULE : STAUDIO.C
|
|
// PURPOSE : Audio Routines
|
|
// AUTHOR : JBS Yadawa
|
|
// CREATED : 7/20/96
|
|
//
|
|
//
|
|
// Copyright (C) 1996 SGS-THOMSON Microelectronics
|
|
//
|
|
//
|
|
// REVISION HISTORY :
|
|
//
|
|
// DATE :
|
|
//
|
|
// COMMENTS :
|
|
//
|
|
|
|
#include "common.h"
|
|
#include "stdefs.h"
|
|
#include "staudio.h"
|
|
#include "debug.h"
|
|
#include "error.h"
|
|
#include "board.h"
|
|
#include "sti3520A.h"
|
|
#include <dos.h> ///////////
|
|
|
|
static PAUDIO pAudio;
|
|
#define SLOW_MODE 0
|
|
#define PLAY_MODE 1
|
|
#define FAST_MODE 2
|
|
|
|
#define IT_A 0 // interrupt detected
|
|
|
|
void AudioOpen(PAUDIO pAud)
|
|
{
|
|
pAudio = pAud;
|
|
pAudio->AudioState = AUDIO_POWER_UP;
|
|
pAudio->IntAudio = NO_IT_A;
|
|
pAudio->MaskItAudio = 0;
|
|
pAudio->ErrorMsg = NO_ERROR;
|
|
pAudio->FirstPTS = FALSE; // First PTS not reached yet
|
|
pAudio->mute = FALSE;
|
|
pAudio->Stepped = FALSE;
|
|
pAudio->FrameCount = 0;
|
|
}
|
|
|
|
void AudioClose(void)
|
|
{
|
|
}
|
|
|
|
void AudioInitDecoder(WORD StreamType)
|
|
{
|
|
/*
|
|
#if 0
|
|
pAudio->StrType = StreamType;
|
|
switch(pAudio->AudioState) {
|
|
case AUDIO_POWER_UP:
|
|
BoardWriteAudio(RESET, 1); // reset the decoder
|
|
//ALTERAClearPendingAudioIT(); // Clear pending audio interrupt generated by soft reset
|
|
BoardWriteAudio(INTR_EN, 0); // disable all interupts
|
|
BoardWriteAudio(INTR_EN + LSB, 0);
|
|
BoardWriteAudio(PLAY, 0); // disable play output
|
|
BoardWriteAudio(MUTE, 0); // do not mute output. LRclk and Sclk Stopped here
|
|
BoardWriteAudio(INVERT_SCLK, 0); // standard
|
|
BoardWriteAudio(INVERT_LRCLK, 1);// standard
|
|
#ifndef VALID3520
|
|
//**************************************************************
|
|
// Philips TDA1311 is a 16 bit DAC (oversampling 1x, 2x, 4x, 8x)
|
|
// -> LRCLK = SCLK / 32
|
|
// -> SCLK = PCMCLK / 8 (8 times oversampling => PCM_DIV = 3)
|
|
// => PCMCLK = 256 * Sampling Frequency
|
|
//**************************************************************
|
|
BoardWriteAudio(PCM_DIV, 3);
|
|
BoardWriteAudio(PCM_ORD, 0); // MSB first
|
|
BoardWriteAudio(PCM_18, 0); // 16 bits of PCM data
|
|
BoardWriteAudio(FORMAT, 0); // I2S output format
|
|
BoardWriteAudio(DIF, 0); // Optionnal in 16 bit output
|
|
#else
|
|
//**************************************************************
|
|
// Crystal CS4330 is an 18 bit DAC (oversampling 1x, 4x, 6x, 8x)
|
|
// -> LRCLK = SCLK / 64
|
|
// -> SCLK = PCMCLK / 4 (4 times oversampling => PCM_DIV = 1)
|
|
// => PCMCLK = 256 * Sampling Frequency
|
|
//**************************************************************
|
|
BoardWriteAudio(PCM_DIV, 1);
|
|
BoardWriteAudio(PCM_ORD, 0);
|
|
BoardWriteAudio(PCM_18, 1); // 18 bits of PCM data
|
|
BoardWriteAudio(FORMAT, 0); // I2S output format
|
|
BoardWriteAudio(DIF, 0); // Optionnal in 16 bit
|
|
#endif
|
|
BoardWriteAudio(STR_SEL, 0); // Default Stream Type is audio elem stream
|
|
BoardWriteAudio(CRC_ECM, 1); // mute on CRC error correction
|
|
BoardWriteAudio(SYNC_ECM, 1); // mute if Sync lost
|
|
BoardWriteAudio(SYNCHRO_CONFIRM, 1); // synchro confirmation mode
|
|
BoardWriteAudio(SYNC_REG, 0x3F); // layer, bitrate, fs fields not used
|
|
BoardWriteAudio(PACKET_SYNC_CHOICE, 0);// multiplexed stream
|
|
BoardWriteAudio(LATENCY, 0x0); // Low Lattency decoding
|
|
BoardWriteAudio(SYNC_LCK, 0x2); // locked after 2 good Sync
|
|
BoardWriteAudio(SIN_EN, 0x01); // Serial data input to enable bit buffer access
|
|
BoardWriteAudio(AUDIO_ID_EN, 0x0);// ignore audio stream ID
|
|
BoardWriteAudio(AUDIO_ID, 0x0); // audio stream ID ignored
|
|
BoardWriteAudio(FREE_FORM_H, 0x0);// not free format
|
|
BoardWriteAudio(FREE_FORM_L, 0x0);
|
|
BoardWriteAudio(DUAL_REG, 0); // Select Stereo Mode
|
|
AudioSetSTCParameters(44100UL);
|
|
BoardAudioSetSamplingFrequency(44100UL);
|
|
pAudio->FrameCount = 0; // Reset Frame Count.
|
|
pAudio->AudioState = AUDIO_INIT;
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
#else
|
|
BoardWriteAudio(0xF0, 1); // reset the decoder
|
|
BoardWriteAudio(0xC6, 0);
|
|
BoardWriteAudio(0xEF, 1);
|
|
BoardWriteAudio(PCM_DIV, 2);
|
|
BoardWriteAudio(0x9f, 0);
|
|
BoardWriteAudio(0x99, 0);
|
|
BoardWriteAudio(0xB6, 3);
|
|
BoardWriteAudio(0x9e, 0);
|
|
BoardWriteAudio(0xa0, 0);
|
|
BoardWriteAudio(0x91, 0);
|
|
BoardWriteAudio(0xb8, 0);
|
|
BoardWriteAudio(0x96, 1);
|
|
BoardWriteAudio(0xd3, 0);
|
|
BoardWriteAudio(0xac, 0);
|
|
BoardWriteAudio(0xc4, 0);
|
|
BoardWriteAudio(0xc2, 1);
|
|
BoardWriteAudio(0xAE, 1);
|
|
|
|
#endif
|
|
*/
|
|
}
|
|
|
|
WORD AudioTestReg(void)
|
|
{
|
|
#if 0
|
|
WORD ReadValue;
|
|
BoardWriteAudio(ATTEN_L, 0x55);
|
|
BoardWriteAudio(ATTEN_R, 0xAA);
|
|
ReadValue = BoardReadAudio(ATTEN_L);
|
|
if ((ReadValue & 0x3F) != 0x15)
|
|
goto Error;
|
|
ReadValue = BoardReadAudio(ATTEN_R);
|
|
if ((ReadValue & 0x3F) != 0x2A)
|
|
goto Error;
|
|
|
|
return NO_ERROR;
|
|
|
|
Error :
|
|
SetErrorCode(ERR_AUDIO_REG_TEST_FAILED);
|
|
return BAD_REG_A;
|
|
#else
|
|
return NO_ERROR;
|
|
#endif
|
|
}
|
|
|
|
WORD AudioTest(void)
|
|
{
|
|
#if 0
|
|
WORD TestResult;
|
|
TestResult = AudioTestReg();
|
|
if (TestResult != NO_ERROR)
|
|
return TestResult;
|
|
else {
|
|
#ifdef DOSAPP
|
|
if (AudioTestInt(pAudio) == NO_IT_A)
|
|
return NO_IT_A;
|
|
else
|
|
#endif
|
|
return NO_ERROR;
|
|
}
|
|
#else
|
|
return NO_ERROR;
|
|
#endif
|
|
}
|
|
|
|
WORD AudioTestInt(void)
|
|
{
|
|
WORD err = NO_ERROR;
|
|
#if 0
|
|
U8 Threshold;
|
|
WORD a = 0;
|
|
|
|
pAudio->MaskItAudio = FIFT;
|
|
Threshold = BoardReadAudio(FIFO_IN_TRESHOLD);
|
|
//---- Configure audio
|
|
BoardWriteAudio(PLAY, 0x00);
|
|
BoardWriteAudio(FIFO_IN_TRESHOLD, 0x01);
|
|
//---- Enable FIFO full interrupt
|
|
BoardWriteAudio(INTR_EN, 0x00);
|
|
BoardWriteAudio(INTR_EN + LSB, 0x10);
|
|
//---- Write a byte to force an interrupt
|
|
BoardWriteAudio(DATA_IN, 0x00);
|
|
// wait for occurrence of first audio interrupt
|
|
while (pAudio->IntAudio == NO_IT_A) {
|
|
Delay(1000);
|
|
a++; /* incremented every 1 ms */
|
|
if (a >= 1000) {
|
|
DPF((Trace, "AudioTestInt failed !!"));
|
|
SetErrorCode(ERR_NO_AUDIO_INTR);
|
|
err = NO_IT_A; /* No interrupt */
|
|
break;
|
|
}
|
|
}
|
|
// Restore Interrupt mask
|
|
pAudio->MaskItAudio = 0;
|
|
AudioMaskInt();
|
|
BoardWriteAudio(FIFO_IN_TRESHOLD, Threshold);
|
|
BoardReadAudio(INTR); /* to clear audio interrupts flags */
|
|
#endif
|
|
return err;
|
|
}
|
|
|
|
// Set the decoding mode and parameters
|
|
|
|
void AudioSetMode(WORD Mode, WORD param)
|
|
{
|
|
#if 0
|
|
pAudio->DecodeMode = Mode;
|
|
switch (pAudio->DecodeMode) {
|
|
case PLAY_MODE:
|
|
BoardWriteAudio(MUTE, 0);
|
|
pAudio->fastForward = 0;
|
|
pAudio->decSlowDown = 0;
|
|
break;
|
|
case FAST_MODE:
|
|
pAudio->fastForward = 1;
|
|
pAudio->decSlowDown = 0;
|
|
break;
|
|
case SLOW_MODE:
|
|
pAudio->fastForward = 0;
|
|
pAudio->decSlowDown = param;
|
|
break;
|
|
}
|
|
#endif
|
|
}
|
|
|
|
// Decode
|
|
void AudioDecode(void)
|
|
{
|
|
#if 0
|
|
switch (pAudio->AudioState) {
|
|
case AUDIO_POWER_UP:
|
|
break;
|
|
case AUDIO_INIT:
|
|
// Change in synchro + buffer over BALF +PTS
|
|
pAudio->MaskItAudio = SYNC|BOF|PCMU|CRC| PTS;
|
|
BoardWriteAudio(INTR_EN, (BYTE)(pAudio->MaskItAudio & 0xFF));
|
|
BoardWriteAudio(INTR_EN + LSB, (BYTE)(pAudio->MaskItAudio >> 8 ));
|
|
//yg BoardWriteAudio(MUTE, 1); // This Starts SClk and LRClk outputs
|
|
BoardWriteAudio(PLAY, 1); // Start decoding Output is Mute
|
|
pAudio->AudioState = AUDIO_STC_INIT;
|
|
break;
|
|
case AUDIO_STC_INIT:
|
|
pAudio->AudioState = AUDIO_DECODE;
|
|
BoardWriteAudio(PLAY, 1); // Restart decoding (decoding had been stopped when first audio PTS detected)
|
|
BoardWriteAudio(MUTE, 0); // Stop Muting output
|
|
break;
|
|
case AUDIO_DECODE:
|
|
break;
|
|
case AUDIO_PAUSE:
|
|
case AUDIO_STEP:
|
|
BoardWriteAudio(PLAY, 1);
|
|
BoardWriteAudio(MUTE, 0);
|
|
pAudio->AudioState = AUDIO_DECODE;
|
|
break;
|
|
}
|
|
#endif
|
|
}
|
|
|
|
void AudioStep(void)
|
|
{
|
|
#if 0
|
|
BoardWriteAudio(MUTE, 0);
|
|
BoardWriteAudio(PLAY, 1);
|
|
pAudio->AudioState = AUDIO_STEP;
|
|
pAudio->Stepped = FALSE;
|
|
#endif
|
|
}
|
|
|
|
void AudioStop(void)
|
|
{
|
|
#if 0
|
|
switch(pAudio->AudioState) {
|
|
case AUDIO_POWER_UP:
|
|
break;
|
|
case AUDIO_INIT:
|
|
break;
|
|
case AUDIO_STC_INIT:
|
|
case AUDIO_DECODE:
|
|
pAudio->AudioState = AUDIO_POWER_UP;
|
|
AudioInitDecoder(pAudio, pAudio->StrType);
|
|
break;
|
|
}
|
|
#endif
|
|
}
|
|
|
|
void AudioPause(void)
|
|
{
|
|
#if 0
|
|
switch(pAudio->AudioState) {
|
|
case AUDIO_POWER_UP: /* After reset */
|
|
case AUDIO_INIT: /* Initialisation + test of the decoders */
|
|
case AUDIO_STC_INIT: /* STC of audio decoder initialized */
|
|
case AUDIO_DECODE: /* Normal decode */
|
|
BoardWriteAudio(MUTE, 1);
|
|
BoardWriteAudio(PLAY, 0);
|
|
pAudio->AudioState = AUDIO_PAUSE;
|
|
break;
|
|
}
|
|
#endif
|
|
}
|
|
|
|
WORD AudioGetState(void)
|
|
{
|
|
return ( pAudio->AudioState);
|
|
}
|
|
|
|
void AudioSetSTCParameters(DWORD SampFreq)
|
|
{
|
|
#if 0
|
|
// Note :
|
|
// STCCLK = PCMCLK (fixed inside STi3520A)
|
|
// (PCMCLK * inc) / div = 90kHz
|
|
switch(SampFreq){
|
|
case 32000UL:
|
|
// PCMCLK = 256 * 32 = 8192 kHz, inc = 45, div = 4096 -> 90kHz
|
|
BoardWriteAudio(STC_INC, 45);
|
|
BoardWriteAudio(STC_DIVH, 0x10);
|
|
BoardWriteAudio(STC_DIVL, 0x00);
|
|
break;
|
|
|
|
case 44100UL:
|
|
// PCMCLK = 256 * 44.1 = 11289.6 kHz, inc = 25, div = 3136 -> 90kHz
|
|
BoardWriteAudio(STC_INC, 25);
|
|
BoardWriteAudio(STC_DIVH, 0x0C);
|
|
BoardWriteAudio(STC_DIVL, 0x40);
|
|
break;
|
|
|
|
case 48000UL:
|
|
// PCMCLK = 256 * 48 = 12288 kHz, inc = 15, div = 2048 -> 90kHz
|
|
BoardWriteAudio(STC_INC, 15);
|
|
BoardWriteAudio(STC_DIVH, 0x08);
|
|
BoardWriteAudio(STC_DIVL, 0x00);
|
|
break;
|
|
|
|
default :
|
|
break;
|
|
}
|
|
|
|
BoardWriteAudio(STC_CTL, 0x40); // Load STC_VID on rising edge of VSYNC
|
|
#endif
|
|
}
|
|
DWORD AudioGetSTC(void)
|
|
{
|
|
#if 0
|
|
DWORD stc;
|
|
WORD j;
|
|
|
|
BoardWriteAudio(STC_CTL, 0x44); // load current STC value to STC
|
|
for ( j = 0; j < 0xF; j++)
|
|
;
|
|
stc = ( BoardReadAudio(STC_3 ) & 0xFFL ) << 24;
|
|
stc = stc | ( ( BoardReadAudio(STC_2 ) & 0xFFL ) << 16);
|
|
stc = stc | ( ( BoardReadAudio(STC_1 ) & 0xFFL ) << 8);
|
|
stc = stc | ( BoardReadAudio(STC_0 ) & 0xFFL);
|
|
return ( stc);
|
|
#else
|
|
return 0;
|
|
#endif
|
|
}
|
|
|
|
DWORD AudioGetVideoSTC(void)
|
|
{
|
|
#if 0
|
|
DWORD stc;
|
|
WORD j;
|
|
|
|
BoardWriteAudio(STC_CTL, 0x48); // load STC_VID to STC, Mode 0 mapping
|
|
// BoardWriteAudio(STC_CTL, 0x44); accu
|
|
// BoardWriteAudio(STC_CTL, 0x50);
|
|
for ( j = 0; j < 0xF; j++)
|
|
;
|
|
/*
|
|
stc = ( BoardReadAudio(STC_3 ) & 0xFFL ) << 24;
|
|
stc = stc | ((BoardReadAudio(STC_2) & 0xFFL ) << 16);
|
|
stc = stc | ((BoardReadAudio(STC_1) & 0xFFL ) << 8);
|
|
stc = stc | ((BoardReadAudio(STC_0) & 0xFFL ));
|
|
*/
|
|
stc = ( BoardReadAudio(STC_0) & 0xFFL ) << 0;
|
|
stc = stc | ((BoardReadAudio(STC_1) & 0xFFL ) << 8);
|
|
stc = stc | ((BoardReadAudio(STC_2) & 0xFFL ) << 16);
|
|
stc = stc | ((BoardReadAudio(STC_3) & 0xFFL ) << 24);
|
|
return stc;
|
|
#else
|
|
return 0;
|
|
#endif
|
|
}
|
|
|
|
void AudioInitSTC(DWORD stc)
|
|
{
|
|
#if 0
|
|
BoardWriteAudio(STC_0, (U8)(stc & 0xFFL));
|
|
stc >>= 8;
|
|
BoardWriteAudio(STC_1, (U8)(stc & 0xFFL));
|
|
stc >>= 8;
|
|
BoardWriteAudio(STC_2, (U8)(stc & 0xFFL));
|
|
stc >>= 8;
|
|
BoardWriteAudio(STC_3, (U8)(stc & 0xFFL));
|
|
BoardWriteAudio(STC_CTL, 0x41); // load STC to accumulator,
|
|
#endif
|
|
}
|
|
|
|
DWORD AudioGetPTS(void)
|
|
{
|
|
return pAudio->PtsAudio;
|
|
}
|
|
|
|
WORD AudioGetErrorMsg(void)
|
|
{
|
|
return pAudio->ErrorMsg;
|
|
}
|
|
|
|
void AudioSetRightVolume(WORD volume)
|
|
{
|
|
#if 0
|
|
BoardWriteAudio(ATTEN_R, (BYTE)volume);
|
|
#endif
|
|
}
|
|
|
|
void AudioSetLeftVolume(WORD volume)
|
|
{
|
|
#if 0
|
|
BoardWriteAudio(ATTEN_L, (BYTE)volume);
|
|
#endif
|
|
}
|
|
|
|
void AudioMute(void)
|
|
{
|
|
#if 0
|
|
if (pAudio->mute) {
|
|
BoardWriteAudio(MUTE, 0);
|
|
pAudio->mute = FALSE;
|
|
}
|
|
else {
|
|
BoardWriteAudio(MUTE, 1);
|
|
pAudio->mute = TRUE;
|
|
}
|
|
#endif
|
|
}
|
|
|
|
BOOL AudioIsFirstPTS(void)
|
|
{
|
|
return pAudio->FirstPTS;
|
|
}
|
|
|
|
void AudioSetStreamType(WORD StrType)
|
|
{
|
|
#if 0
|
|
BoardWriteAudio(STR_SEL, (BYTE)StrType);
|
|
#endif
|
|
}
|
|
void AudioInitPesParser (WORD StreamType)
|
|
{
|
|
#if 0
|
|
switch(StreamType)
|
|
{
|
|
case SYSTEM_STREAM:
|
|
case VIDEO_PACKET:
|
|
case AUDIO_PACKET:
|
|
case VIDEO_PES:
|
|
case AUDIO_PES:
|
|
|
|
BoardWriteAudio( STR_SEL, 1);
|
|
break;
|
|
case DUAL_PES:
|
|
BoardWriteAudio( STR_SEL, 4);
|
|
break;
|
|
case DUAL_ES:
|
|
BoardWriteAudio( STR_SEL, 0);
|
|
break;
|
|
case VIDEO_STREAM:
|
|
case AUDIO_STREAM:
|
|
BoardWriteAudio( STR_SEL, 0);
|
|
break;
|
|
|
|
}
|
|
#endif
|
|
}
|
|
void AudioMaskInt(void)
|
|
{
|
|
#if 0
|
|
BoardWriteAudio(INTR_EN, 0);
|
|
BoardWriteAudio(INTR_EN + LSB, 0);
|
|
#endif
|
|
}
|
|
|
|
void AudioRestoreInt(void)
|
|
{
|
|
#if 0
|
|
//HostDisplay(DISPLAY_FASTEST, "!%x!", pAudio->MaskItAudio);
|
|
BoardWriteAudio(INTR_EN, (BYTE)(pAudio->MaskItAudio & 0xFF));
|
|
BoardWriteAudio(INTR_EN + LSB, (BYTE)(pAudio->MaskItAudio >> 8));
|
|
#endif
|
|
}
|
|
|
|
BOOL AudioAudioInt(void)
|
|
{
|
|
#if 0
|
|
WORD int_stat_reg, i;
|
|
BOOLEAN bAudioIntr = FALSE;
|
|
|
|
// Read the interrupt status register
|
|
int_stat_reg = BoardReadAudio(INTR);
|
|
i = BoardReadAudio(INTR + LSB);
|
|
i = i << 8;
|
|
int_stat_reg = ( int_stat_reg & 0xFF ) | i;
|
|
int_stat_reg = int_stat_reg & pAudio->MaskItAudio; /* Mask the IT not used */
|
|
if(int_stat_reg)
|
|
bAudioIntr = TRUE;
|
|
|
|
/******************************************************/
|
|
/** FIFO FULL used to test audio interrupt generation**/
|
|
/******************************************************/
|
|
if (int_stat_reg & FIFT) {
|
|
pAudio->IntAudio = IT_A;
|
|
}
|
|
/******************************************************/
|
|
/** CHANGE SYNCHRO **/
|
|
/******************************************************/
|
|
if (int_stat_reg & SYNC) {
|
|
i = BoardReadAudio(SYNC_ST); // Synchronization status
|
|
if ((i & 0x3) == 3) { // Locked
|
|
// Disable Change in synchro
|
|
pAudio->MaskItAudio = pAudio->MaskItAudio & NSYNC;
|
|
// Next Interrupt should be change in sampling freq
|
|
pAudio->MaskItAudio = pAudio->MaskItAudio | SAMP;
|
|
}
|
|
}
|
|
|
|
/******************************************************/
|
|
/** CHANGE IN SAMPLING FREQUENCY **/
|
|
/******************************************************/
|
|
if (int_stat_reg & SAMP) {
|
|
i = BoardReadAudio(PCM_FS ) & 0x3; // Get Sampling frequency
|
|
switch(i) {
|
|
case 0 :
|
|
BoardAudioSetSamplingFrequency(44100UL);
|
|
AudioSetSTCParameters(44100UL);
|
|
break;
|
|
case 1 :
|
|
BoardAudioSetSamplingFrequency(48000UL);
|
|
AudioSetSTCParameters(48000UL);
|
|
break;
|
|
case 2 :
|
|
BoardAudioSetSamplingFrequency(32000UL);
|
|
AudioSetSTCParameters(32000UL);
|
|
break;
|
|
default :
|
|
break;
|
|
}
|
|
// Disable change in sampling frequency
|
|
pAudio->MaskItAudio = pAudio->MaskItAudio & NSAMP;
|
|
}
|
|
|
|
/******************************************************/
|
|
/** CRC error **/
|
|
/******************************************************/
|
|
if (int_stat_reg & CRC) {
|
|
}
|
|
|
|
/******************************************************/
|
|
/** PCM Underflow **/
|
|
/******************************************************/
|
|
if (int_stat_reg & PCMU) {
|
|
}
|
|
|
|
/******************************************************/
|
|
/** Begining of Frame **/
|
|
/******************************************************/
|
|
if (int_stat_reg & BOF) {
|
|
DWORD STC = AudioGetVideoSTC();
|
|
static DWORD STCOld;
|
|
|
|
// HostDisplay(DISPLAY_FASTEST, "STCBOF = %8lu D = %5ld\r\n", STC, STC - STCOld);
|
|
// STCOld = STC;
|
|
|
|
// Check if stepping
|
|
if ((pAudio->AudioState == AUDIO_STEP) && (pAudio->Stepped == FALSE)) {
|
|
BoardWriteAudio(MUTE, 1);
|
|
BoardWriteAudio(PLAY, 0);
|
|
pAudio->Stepped = TRUE;
|
|
}
|
|
// If Slow motion or Fast forward, Mute Audio
|
|
if ( pAudio->DecodeMode != PLAY_MODE ) {
|
|
BoardWriteAudio(MUTE, 1);
|
|
pAudio->mute = TRUE;
|
|
if ((pAudio->FrameCount % 4) && (pAudio->fastForward))
|
|
BoardWriteAudio(SKIP, 1);
|
|
else if ((pAudio->DecodeMode == SLOW_MODE ) &&
|
|
((pAudio->FrameCount % (pAudio->decSlowDown + 1)) != 0))
|
|
BoardWriteAudio(REPEAT, 1);
|
|
}
|
|
|
|
pAudio->FrameCount++; // Increment Frame Count
|
|
}
|
|
|
|
/******************************************************/
|
|
/** PTS detected **/
|
|
/******************************************************/
|
|
if ( int_stat_reg & PTS ) {
|
|
DWORD pts;
|
|
//DBG1('p');
|
|
/*
|
|
BoardReadAudio(PTS_4); // To clear pts interrupt
|
|
pts = (BoardReadAudio(PTS_3) & 0xFFL) << 24;
|
|
pts = pts | ((BoardReadAudio(PTS_2 ) & 0xFFL) << 16);
|
|
pts = pts | ((BoardReadAudio(PTS_1 ) & 0xFFL) << 8);
|
|
pts = pts | ( BoardReadAudio(PTS_0 ) & 0xFFL);
|
|
*/
|
|
pts = (BoardReadAudio(PTS_0) & 0xFFL) << 0;
|
|
pts = pts | ((BoardReadAudio(PTS_1) & 0xFFL) << 8);
|
|
pts = pts | ((BoardReadAudio(PTS_2) & 0xFFL) << 16);
|
|
pts = pts | ((BoardReadAudio(PTS_3) & 0xFFL) << 24);
|
|
BoardReadAudio(PTS_4); // To clear pts interrupt
|
|
|
|
pAudio->PtsAudio = pts;
|
|
if (pAudio->AudioState == AUDIO_STC_INIT) {
|
|
pAudio->FirstPTS = TRUE;
|
|
//yg BoardWriteAudio(PLAY, 0);
|
|
}
|
|
if (pAudio->AudioState == AUDIO_DECODE) {
|
|
// HostDirectPutChar('P', BLACK, LIGHTBLUE);
|
|
AudioInitSTC ( pts);
|
|
// DWORD STC = AudioGetVideoSTC();
|
|
// HostDisplay(DISPLAY_FASTEST, "STC = %8lu PTSA = %8lu D = %8ld\r\n", STC, pts, STC - pts);
|
|
}
|
|
}
|
|
|
|
return bAudioIntr;
|
|
#else
|
|
return FALSE;
|
|
#endif
|
|
}
|
|
|
|
|