📄 clkrvsim.c
字号:
else
{
STC_Ticks_To_Increment = STC_Ticks_Elapsed - FilePrevSTC;
PCR_Ticks_To_Increment = PCR_Ticks_Elapsed - FilePrevPCR;
FilePrevSTC = STC_Ticks_Elapsed;
FilePrevPCR = PCR_Ticks_Elapsed;
}
}
}
/* Go inside if only if Interrupt is not to be generated in this iteration */
if(((ControlObject_p->DriftCorrection) && (RefCounter > ((U32)STC_Ticks_To_Increment +
Glitch_Ticks_To_Increment))) || (!ControlObject_p->DriftCorrection))
{
/* Increment the Counters with the ticks calculated as above */
STCCounter += ((U32)STC_Ticks_To_Increment - InterruptSTCticks);
PCRCounter += ((U32)PCR_Ticks_To_Increment - InterruptPCRticks);
#ifdef ST_5188
PcrDataSim.member.PCREventData.DiscontinuityFlag = 0;
/* Loss of accuracy here */
PcrDataSim.member.PCREventData.PCRBase.LSW = (PCRCounter / DIV_90KHZ_27MHZ);
PcrDataSim.member.PCREventData.PCRExtension = (PCRCounter % DIV_90KHZ_27MHZ);
PcrDataSim.member.PCREventData.PCRArrivalTime.Bit32 = 0;
PcrDataSim.member.PCREventData.PCRBase.Bit32 = 0;
PcrDataSim.ObjectHandle = CLKRV_SLOT_1; /* As set in Test
* App SetPCRSource()*/
PcrDataSim.member.PCREventData.PCRArrivalTime.LSW = (U32)((STCCounter
+ Glitch_Ticks_To_Increment)
/ DIV_90KHZ_27MHZ);
PcrDataSim.member.PCREventData.PCRArrivalTimeExtension = (U32)((STCCounter
+ Glitch_Ticks_To_Increment)
% DIV_90KHZ_27MHZ);
#else
PcrDataSim.u.PCREventData.DiscontinuityFlag = 0;
/* Loss of accuracy here */
PcrDataSim.u.PCREventData.PCRBase.LSW = (PCRCounter / DIV_90KHZ_27MHZ);
PcrDataSim.u.PCREventData.PCRExtension = (PCRCounter % DIV_90KHZ_27MHZ);
PcrDataSim.u.PCREventData.PCRArrivalTime.Bit32 = 0;
PcrDataSim.u.PCREventData.PCRBase.Bit32 = 0;
PcrDataSim.SlotHandle = CLKRV_SLOT_1; /* As set in Test
* App SetPCRSource()*/
PcrDataSim.u.PCREventData.PCRArrivalTime.LSW = (U32)((STCCounter
+ Glitch_Ticks_To_Increment)
/ DIV_90KHZ_27MHZ);
PcrDataSim.u.PCREventData.PCRArrivalTimeExtension = (U32)((STCCounter
+ Glitch_Ticks_To_Increment)
% DIV_90KHZ_27MHZ);
#endif
/* Notify Driver */
STEVT_Notify(ControlObject_p->Evt.EVTHandlePcr, CLKRVEventIDSIM, &PcrDataSim);
/* Filter will take 100 micro-seconds */
STOS_TaskDelay(ST_GetClocksPerSecond()/1000);
/* If Drift Correction is ON Increment PCM and SPDIf counters too */
if(ControlObject_p->DriftCorrection)
{
RefCounter = RefCounter - ((U32)STC_Ticks_To_Increment * PacketDrop +
Glitch_Ticks_To_Increment)+ InterruptSTCticks;
/* Debug message - should never happen though */
if((S32)RefCounter < 0)
{
STTBX_Print(( "\n***Reference Counter became Negative ***\n" ));
}
if(!ControlObject_p->FileTest)
{
PCMCounter += (U32) ((U32)(((double)PCR_Interval * (double)PCMFreq * PacketDrop +
PCMCorrection ) / K ) + (Glitch_Ticks_To_Increment / PCM_Ratio)
- InterruptAudioticks);
SPDIFCounter += (U32) ((U32)(((double)PCR_Interval * (double)SPDIFFreq * PacketDrop +
SPDIFCorrection) / K ) + (Glitch_Ticks_To_Increment / SPDIF_Ratio)
- InterruptSPDIFticks);
PCMCorrection += (((U32)((double) PCMFreq * (double)PCR_Interval )) % K );
SPDIFCorrection += (((U32)((double) SPDIFFreq * (double)PCR_Interval )) % K );
}
else
{
PCMCounter += (U32)((STC_Ticks_To_Increment / PCM_Ratio)- InterruptAudioticks);
SPDIFCounter += (U32)((STC_Ticks_To_Increment / SPDIF_Ratio)- InterruptSPDIFticks);
PCMCorrection += ((U32)(STC_Ticks_To_Increment / PCM_Ratio) % K );
SPDIFCorrection += ((U32)(STC_Ticks_To_Increment / SPDIF_Ratio) % K );
}
if(PCMCorrection >= K)
{
PCMCorrection = PCMCorrection - K;
}
if(SPDIFCorrection >= K)
{
SPDIFCorrection = SPDIFCorrection - K;
}
/* Update the respective counters */
ClkrvSim_RegWrite(CLKRVSIM_RegArray, CAPTURE_COUNTER_PCM, PCMCounter);
#if defined (ST_5100) || defined (ST_5105) || defined (ST_5301) || defined (ST_5107)
ClkrvSim_RegWrite(CLKRVSIM_RegArray, CAPTURE_COUNTER_SPDIF, SPDIFCounter);
#elif defined (ST_7710) || defined (ST_7100)
ClkrvSim_RegWrite(CLKRVSIM_RegArray, CAPTURE_COUNTER_HD, SPDIFCounter);
#endif
}
/* Print Data to Excel File */
fprintf((ControlObject_p->TaskContext.Logfile_p),"%u,%u,%u,%u,%u,%d,%d,%d,%d,%d,%d,%u,"
"%u,%u\n",ClkrvDbg[0][0],ClkrvDbg[5][0],ClkrvDbg[1][0],ClkrvDbg[3][0],ClkrvDbg[2][0],
ClkrvDbg[8][0],ClkrvDbg[4][0],ClkrvDbg[7][0],ClkrvDbg[6][0],ClkrvDbg[9][0],ClkrvDbg[10][0],ClkrvDbg[11][0],
Clkrv_Slave_Dbg[0][0],Clkrv_Slave_Dbg[1][0]);
InterruptAudioticks = InterruptSPDIFticks = 0;
InterruptSTCticks = InterruptPCRticks = 0;
/* Update the Frequencies */
if(ClkrvDbg[1][0] != 0)
{
#ifdef WA7710_35956
SDFreq = (ClkrvDbg[1][0] * 10) /55;
#else
SDFreq = ClkrvDbg[1][0];
#endif
SPDIFFreq = Clkrv_Slave_Dbg[0][0];
PCMFreq = Clkrv_Slave_Dbg[1][0];
}
SampleCount = 0;
}
else /* Generate Interrupt */
{
InterruptSTCticks = RefCounter;
/* Debug Message - would never happen though */
if((RefCounter > (U32)STC_Ticks_Elapsed )&&(RefCounter < (U32)STC_Ticks_To_Increment))
{
STTBX_Print(( "\n***Interrupt invoked when Stream Status = %d***\n",StreamStatus));
}
/* Reload Actual Reference Counter value */
RefCounter = RefCntMaxVal ;
ClkrvSim_RegWrite(CLKRVSIM_RegArray, REF_MAX_CNT, RefCounter);
if(PCMFreq) /* Just a double check */
{
/* Now get the audio counter value at the instance interrupt is generated */
/* check accuracy here */
InterruptAudioticks = (U32)(((double)InterruptSTCticks * (double)PCMFreq) /
(double)SDFreq);
PCMCounter += InterruptAudioticks;
ClkrvSim_RegWrite(CLKRVSIM_RegArray, CAPTURE_COUNTER_PCM, PCMCounter);
}
else
{
STTBX_Print(( "BY-PASSSING PCM FREQUENCY Since PCM not Set:\n" ));
}
/* Now get the SPDIF counter value at the instance interrupt is generated */
if(SPDIFFreq)
{
InterruptSPDIFticks = (U32)(((double)InterruptSTCticks * (double)SPDIFFreq) /
(double)SDFreq);
SPDIFCounter += InterruptSPDIFticks;
#if defined (ST_5100) || defined (ST_5105) || defined (ST_5301) || defined (ST_5107)
ClkrvSim_RegWrite(CLKRVSIM_RegArray, CAPTURE_COUNTER_SPDIF, SPDIFCounter);
#elif defined (ST_7710) || defined (ST_7100)
ClkrvSim_RegWrite(CLKRVSIM_RegArray, CAPTURE_COUNTER_HD, SPDIFCounter);
#endif
}
else
{
STTBX_Print(( "BY-PASSSING SPDIF:\n" ));
}
/* Increment STC and PCR counters Too */
InterruptPCRticks = (U32)(((double)InterruptSTCticks * (double)EncoderFrequency) /
(double)SDFreq);
PCRCounter += InterruptPCRticks ;
STCCounter += InterruptSTCticks ;
/* Generate Interupt Now */
ClkrvSim_RegRead(CLKRVSIM_RegArray, CLK_REC_CMD, &CmdReg);
ClkrvSim_RegWrite(CLKRVSIM_RegArray, CLK_REC_CMD,(CmdReg |0x02));
interrupt_raise_number(ControlObject_p->InterruptNumber);
}
}
/* Reset all local variables before changing state from RUNNING to INITIALIZED
* and prevent any side effects next time
*/
else
{
STOS_TaskDelay(ST_GetClocksPerSecond()/1000); /* Bad simulator design TBCorrected at some point later */
if(ControlObject_p->SimReset == 1)
{
SDFreq = DEFAULT_SD_FREQUENCY;
PCMFreq = PCM_CLOCK_FREQ1;
SPDIFFreq = PCM_CLOCK_FREQ2;
PCRCounter = 0;
STCCounter = 0;
RefCounter = 0;
PCMCounter = 0;
SPDIFCounter = 0;
EncoderFrequency = 0;
DriftThreshold = 0;
PCR_Interval = 0;
PacketDrop = 0;
StreamStatus = 0;
Jitter = 0;
MaxJitter = 0;
PCR_Ticks_To_Increment = 0;
STC_Ticks_To_Increment = 0;
Glitch_Ticks_To_Increment= 0;
STC_Ticks_Elapsed = 0;
PCR_Ticks_Elapsed = 0;
RetVal = 0;
RefCounter = 0;
RefCntMaxVal = 0;
CmdReg = 0;
STCCorrection = 0;
PCRCorrection = 0;
PCMCorrection = 0;
SPDIFCorrection = 0;
InterruptAudioticks = 0;
InterruptSPDIFticks = 0;
InterruptPCRticks = 0,
InterruptSTCticks = 0;
FilePrevSTC = 0;
FilePrevPCR = 0;
ControlObject_p->SimReset= 0;
}
/* Do Anything else - ??? */
}
}
}
/****************************************************************************
Name : NetworkJitter()
Description : Returns a signed random number which is limited by
value set by CLKRVSIM_SetJitterMax call.
Parameters : NONE
Return Value : Returns a signed random number
****************************************************************************/
static S32 NetworkJitter(S32 MaxJitter)
{
U32 Sign =0;
S32 Jitter = 0;
if(0 == MaxJitter)
{
return 0;
}
else
{
Jitter = rand() % MaxJitter;
Sign = rand() % MaxJitter;
if ( Sign > (MaxJitter/2))
{
return Jitter;
}
else
{
return -Jitter;
}
}
}
/****************************************************************************
Name : exit_simulator_task
Description : On Task Exit Handler
Parameters : NONE
Return Value : NONE
****************************************************************************/
void exit_simulator_task(task_t* task, S32 param)
{
}
/****************************************************************************
Name : ClkrvSim_RegWrite()
Description : Write to Register Array
Parameters : Pointer to BaseAddress of the Array
Register Offset
Value to write to Register
Return Value : void
****************************************************************************/
__inline void ClkrvSim_RegWrite(U32 *BaseAddress, U32 Register, U32 Value)
{
*((U32 *)((U32)BaseAddress + Register)) = Value;
}
/****************************************************************************
Name : ClkrvSim_RegRead()
Description : Read from Register Array
Parameters : Pointer to BaseAddress of the Array
Register Offset
Pointer to variable in which to store the Read Value
Return Value : void
****************************************************************************/
__inline void ClkrvSim_RegRead(U32 *BaseAddress, U32 Register, U32* ReadVal )
{
*ReadVal = *((U32 *)((U32)BaseAddress + Register));
}
/* End of clkrvsim.c*/
⌨️ 快捷键说明
复制代码
Ctrl + C
搜索代码
Ctrl + F
全屏模式
F11
切换主题
Ctrl + Shift + D
显示快捷键
?
增大字号
Ctrl + =
减小字号
Ctrl + -