archive
/
windows-xp
mirror of https://github.com/tongzx/nt5src
2
0
Fork 0
Code Issues Projects Releases Wiki Activity
Source code of Windows XP (NT5)
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.
6 Commits
1 Branch
0 Tags
2.0 GiB
 
 
 
 
 
 
Tree: daad8a087a
Branches Tags
${ item.name }
Create tag ${ searchTerm }
Create branch ${ searchTerm }
from 'daad8a087a'
${ noResults }
windows-xp/Source/XPSP1/NT/drivers/wdm/dvd/mini/jbs/sti3520a.c

3626 lines
116 KiB
Raw Blame History

//
// MODULE : STi3520A.C
// PURPOSE : STi3520A specific code
// AUTHOR : JBS Yadawa
// CREATED : 7/20/96
//
//
// Copyright (C) 1996 SGS-THOMSON Microelectronics
//
//
// REVISION HISTORY :
//
// DATE :
//
// COMMENTS :
//
#include "common.h"
#include "strmini.h"
#include "stdefs.h"
#include "common.h"
#include "debug.h"
#include "board.h"
#include "error.h"
#include "sti3520A.h"
static BYTE DefIntQuant[QUANT_TAB_SIZE] = {
0x08, 0x10, 0x10, 0x13, 0x10, 0x13, 0x16, 0x16,
0x16, 0x16, 0x16, 0x16, 0x1A, 0x18, 0x1A, 0x1B,
0x1B, 0x1B, 0x1A, 0x1A, 0x1A, 0x1A, 0x1B, 0x1B,
0x1B, 0x1D, 0x1D, 0x1D, 0x22, 0x22, 0x22, 0x1D,
0x1D, 0x1D, 0x1B, 0x1B, 0x1D, 0x1D, 0x20, 0x20,
0x22, 0x22, 0x25, 0x26, 0x25, 0x23, 0x23, 0x22,
0x23, 0x26, 0x26, 0x28, 0x28, 0x28, 0x30, 0x30,
0x2E, 0x2E, 0x38, 0x38, 0x3A, 0x45, 0x45, 0x53
};
// Default Non Intra Table
static BYTE DefNonIntQuant[QUANT_TAB_SIZE];
// Non Default Table
static BYTE QuantTab[QUANT_TAB_SIZE];
BYTE Sequence = 1;
extern WORD synchronizing;
char seq_occured;
PVIDEO pVideo;
extern PCARD pCard;
static void NEARAPI ReadHeaderDataFifo (void);
static void NEARAPI VideoAssociatePTS (void);
static void NEARAPI VideoNextStartCode (WORD i);
static void NEARAPI VideoSequenceHeader(void);
static void NEARAPI VideoExtensionHeader(void);
static void NEARAPI VideoGopHeader(void);
static void NEARAPI VideoPictureHeader(void);
static void NEARAPI VideoPictExtensionHeader(void);
static void NEARAPI VideoUser(void);
static void NEARAPI VideoSetRecons(void);
static void NEARAPI VideoStoreRFBBuf (WORD rfp, WORD ffp, WORD bfp );
static void NEARAPI VideoVsyncRout(void);
static void NEARAPI VideoChooseField(void);
static BOOL NEARAPI IsChipSTi3520(void);
static void NEARAPI VideoSetABStart(WORD abg);
static void NEARAPI VideoSetABStop(WORD abs);
static void NEARAPI VideoSetABThresh(WORD abt) ;
static void NEARAPI VideoSetBBStart(WORD bbg);
static WORD NEARAPI VideoGetBBL(void);
static void NEARAPI VideoSetBBStop(WORD bbs);
static void NEARAPI VideoSetBBThresh(WORD bbt);
static WORD NEARAPI VideoBlockMove(DWORD SrcAddress, DWORD DestAddress, WORD Size);
static void NEARAPI VideoStartBlockMove(DWORD SrcAddress, DWORD DestAddress, DWORD Size);
static void NEARAPI VideoCommandSkip(WORD Nbpicture);
static void NEARAPI VideoSetSRC(WORD SrceSize, WORD DestSize);
static void NEARAPI VideoLoadQuantTables(BOOL Intra,BYTE * Table );
static void NEARAPI VideoComputeInst(void);
static void NEARAPI VideoWaitDec (void);
static void NEARAPI VideoStoreINS (void);
static DWORD NEARAPI ReadCDCount (void);
static DWORD NEARAPI ReadSCDCount (void);
static void NEARAPI VideoSetMWP(DWORD mwp);
static void NEARAPI VideoSetMRP(DWORD mrp);
static BOOL NEARAPI VideoMemWriteFifoEmpty( void );
static BOOL NEARAPI VideoMemReadFifoFull( void );
static BOOL NEARAPI VideoHeaderFifoEmpty( void );
static BOOL NEARAPI VideoBlockMoveIdle( void );
static void NEARAPI VideoEnableDecoding(BOOL OnOff);
static void NEARAPI VideoEnableErrConc(BOOL OnOff);
static void NEARAPI VideoPipeReset (void);
static void NEARAPI VideoSoftReset (void);
static void NEARAPI VideoEnableInterfaces (BOOL OnOff );
static void NEARAPI VideoPreventOvf(BOOL OnOff );
static void NEARAPI VideoSetFullRes(void);
static void NEARAPI VideoSetHalfRes(void);
static void NEARAPI VideoSelect8M(BOOL OnOff);
static void NEARAPI VideoSetDramRefresh(WORD Refresh);
static void NEARAPI VideoSelect20M(BOOL OnOff);
static void NEARAPI VideoSetDFA(WORD dfa);
static void NEARAPI VideoDisableDisplay(void);
static void NEARAPI VideoEnableDisplay(void);
static void NEARAPI VideoInitVar(STREAMTYPE StreamType);
static void NEARAPI VideoReset35XX(STREAMTYPE StreamType);
static void NEARAPI VideoInitPLL(void);
static void NEARAPI VideoOsdOn(void);
static void NEARAPI VideoOsdOff (void);
static void NEARAPI VideoInitOEP (DWORD point_oep);
static void NEARAPI VideoDisplayCtrl(void);
static void NEARAPI VideoSetPSV(void);
static void NEARAPI VideoSRCOn(void);
static void NEARAPI VideoSRCOff (void);
static void NEARAPI VideoFullOSD (WORD col);
static void NEARAPI VideoSeek(STREAMTYPE StreamType);
BOOL FARAPI VideoOpen(void)
{
pVideo = pCard->pVideo;
pVideo->errCode = NO_ERROR;
pVideo->VideoState = StatePowerup;
pVideo->ActiveState = StatePowerup;
return (pVideo->errCode);
}
void FARAPI VideoClose(void)
{
}
void FARAPI VideoInitDecoder(STREAMTYPE StreamType)
{
VideoInitVar(StreamType);
VideoReset35XX(StreamType);
pVideo->VideoState = StateInit;
pVideo->ActiveState = StateInit;
}
void FARAPI VideoSeekDecoder(STREAMTYPE StreamType)
{
VideoInitVar(StreamType);
VideoSeek(StreamType);
pVideo->VideoState = StateInit;
pVideo->ActiveState = StateInit;
}
void FARAPI VideoSetMode(WORD Mode, WORD param)
{
pVideo->DecodeMode = Mode;
switch(pVideo->DecodeMode) {
case PlayModeNormal:
pVideo->fastForward = 0;
pVideo->decSlowDown = 0;
break;
case PlayModeFast:
pVideo->fastForward = 1;
pVideo->decSlowDown = 0;
break;
case PlayModeSlow:
pVideo->fastForward = 0;
pVideo->decSlowDown = param;
break;
}
}
void FARAPI VideoDecode(void)
{
switch (pVideo->VideoState) {
case StatePowerup:
break; /* Video chip is not intialized */
case StateInit: /* Starts first Sequence search. */
HostDisableIT();
BoardWriteVideo(ITM, 0);
pVideo->intMask = PSD | HIT | TOP | BOT;
BoardWriteVideo ( ITM + 1, (BYTE)(pVideo->intMask));
BoardWriteVideo(ITM1, 0);
HostEnableIT();
pVideo->VideoState = StateStartup;
pVideo->ActiveState = StateStartup;
break;
case StateStartup:
case StateWaitForDTS:
case StateDecode:
break;
case StatePause:
case StateStep:
HostDisableIT();
pVideo->VideoState = pVideo->ActiveState;
HostEnableIT();
break;
}
}
void FARAPI VideoStep(void)
{
switch(pVideo->VideoState) {
case StatePowerup:
case StateInit:
break;
case StateStartup:
case StateWaitForDTS:
case StateDecode:
VideoPause();
VideoStep(); // Recurse call !
break;
case StateStep:
break;
case StatePause:
if ((!pVideo->displaySecondField) && (!(BoardReadVideo(CTL) & 0x4)))
pVideo->displaySecondField = 1;
else
pVideo->VideoState = StateStep; /* One single picture will be decoded */
pVideo->perFrame = TRUE;
}
}
void FARAPI VideoBack(void)
{
switch (pVideo->VideoState) {
case StatePowerup:
case StateInit:
case StateStep:
break;
case StateWaitForDTS:
case StateStartup:
case StateDecode:
VideoPause();
case StatePause:
pVideo->displaySecondField = 0;
break;
}
}
void FARAPI VideoStop(void)
{
switch (pVideo->VideoState) {
case StatePowerup:
break;
case StateInit:
break;
case StateStartup:
case StateWaitForDTS:
case StateDecode:
case StateStep:
case StatePause:
pVideo->VideoState = StatePowerup;
VideoInitDecoder(DUAL_PES);
VideoMaskInt();
break;
}
}
void FARAPI VideoPause(void)
{
switch (pVideo->VideoState) {
case StatePowerup: // Not yet decoding
case StateInit: // Not yet decoding
case StatePause: // already in Pause mode
break;
case StateWaitForDTS:
case StateStartup:
case StateDecode:
case StateStep:
pVideo->VideoState = StatePause;
break;
}
/* When the video controller is in PAUSE state, the program will not store
any new instruction into the video decoder */
}
BOOL FARAPI AudioIsEnoughPlace(WORD size)
{
if (VideoGetABL() >= (pVideo->AudioBufferSize - (size >> 8)) - 1)
return FALSE;
else
return TRUE;
}
BOOL FARAPI VideoIsEnoughPlace(WORD size)
{
if (VideoGetBBL() >= (pVideo->VideoBufferSize - (size >> 8)) - 1)
return FALSE;
else
return TRUE;
}
DWORD FARAPI VideoGetFirstDTS(void)
{
DWORD Ditiesse;
WORD lattency = 1500; /* field duration for 60 Hz video */
if (pVideo->StreamInfo.displayMode == 0)
lattency = 1800; /* field duration for 50 Hz video */
/* a B picture is displayed 1 field after its decoding starts
an I or a P picture is displayed 3 fields after decoding starts */
if (pVideo->pDecodedPict->pict_type != 2) // I or P picture
lattency = lattency * 3;
Ditiesse = pVideo->pDecodedPict->dwPTS;
Ditiesse = Ditiesse - lattency;
return Ditiesse;
}
WORD FARAPI VideoGetErrorMsg(void)
{
return pVideo->errCode;
}
void FARAPI VideoSkip(void)
{
pVideo->fastForward = 1;
/* the variable will come back to zero when skip instruction is computed */
/* only if pVideo->DecodeMode != VIDEO_FAST */
}
void FARAPI VideoRepeat(void)
{
pVideo->decSlowDown = 1;
/* The variable will come back to zero when repeat done */
/* only if pVideo->DecodeMode != VIDEO_SLOW */
}
WORD FARAPI VideoGetState(void)
{
return pVideo->VideoState;
}
DWORD FARAPI VideoGetPTS(void)
{
return pVideo->pCurrDisplay->dwPTS;
}
BOOL FARAPI VideoIsFirstDTS(void)
{
return pVideo->FirstDTS;
}
BOOL FARAPI VideoIsFirstField(void)
{
if ((pVideo->VsyncNumber == 1) && (pVideo->VsyncInterrupt == TRUE))
return TRUE;
else
return FALSE;
}
BOOL FARAPI VideoForceBKC(BOOL bEnable)
{
if(bEnable)
pVideo->currDCF = pVideo->currDCF & 0xDF; // FBC
else
pVideo->currDCF = pVideo->currDCF | 0x20; // Don't FBC
return TRUE;
}
void FARAPI VideoMaskInt (void)
{
BoardWriteVideo( ITM, 0 ); // mask chip interrupts before reading the status
BoardWriteVideo( ITM + 1, 0 ); // avoids possible gliches on the IRQ line
BoardWriteVideo( VID_ITM1, 0 ); // mask chip interrupts before
}
void FARAPI VideoRestoreInt (void)
{
BoardWriteVideo( ITM, (BYTE)( pVideo->intMask >> 8 ) );
BoardWriteVideo( ITM + 1,(BYTE) ( pVideo->intMask & 0xFF ) );
}
BOOL FARAPI VideoVideoInt(void)
{
BOOL VideoITOccured = FALSE;
WORD compute;
pVideo->VsyncInterrupt = FALSE;
pVideo->FirstDTS = FALSE;
BoardReadVideo ( ITS1 );
/* All interrupts except the first one are computed in this area */
pVideo->intStatus = (WORD)BoardReadVideo ( ITS ) << 8;
// Reading the interrupt status register
pVideo->intStatus = BoardReadVideo ( ITS + 1 ) | pVideo->intStatus;
// All the STI3500 interrupts are cleared */
pVideo->intStatus = pVideo->intStatus & pVideo->intMask;
// To mask the IT not used */
while ( pVideo->intStatus )
{
VideoITOccured = TRUE;
/******************************************************/
/** BOTTOM VSYNC INTERRUPT **/
/******************************************************/
if ( ( pVideo->intStatus & BOT ) != 0x0 )
{
pVideo->intStatus = pVideo->intStatus & ~BOT;
// clear BOT bit
VideoChooseField ();
pVideo->currField = BOT;
if(pVideo->InvertedField)
pVideo->currField = TOP;
VideoVsyncRout ();
}
/******************************************************/
/** TOP VSYNC INTERRUPT **/
/******************************************************/
if ( ( pVideo->intStatus & TOP ) != 0x0 )
{
pVideo->intStatus = pVideo->intStatus & ~TOP;
// clear TOP bit
VideoChooseField ();
pVideo->currField = TOP;
if(pVideo->InvertedField)
pVideo->currField = BOT;
VideoVsyncRout ();
}
/******************************************************/
/** DSYNC INTERRUPT **/
/******************************************************/
/***************************************************************/
/* The DSYNC interrupt is generated on each VSYNC (RPT = 0) */
/* if the next INStrucztion has the EXE bit set. */
/* On each DSYNC a new Header Search is automatically started. */
/***************************************************************/
if ( ( pVideo->intStatus & PSD ) != 0x0 )
{
pVideo->intStatus = pVideo->intStatus & ~PSD;
// clear PSD bit
pVideo->VsyncNumber = 0; /* clear software watch-dog */
/* check if we have reached the first picture with a PTS */
if ( pVideo->NextInstr.Seq ) // first interrupt enabled (Searching Sequence)
{
VideoWaitDec (); // put decoder in Wait mode
pVideo->intMask = 0x1; /* enable header hit interrupt */
pVideo->NextInstr.Seq = 0;
pVideo->NextInstr.Exe = 0;
}
else
{
Sequence = 0;
if ( VideoGetState () == StateWaitForDTS )
{
if ( pVideo->pDecodedPict->validPTS == TRUE )
{
pVideo->FirstDTS = TRUE;
pVideo->VideoState = StateDecode;
}
}
/* Check bit buffer level consistency with pVideo->vbveDelay */
/* of the picture that the STi3500 starts to decode */
if ( ( pVideo->fieldMode == 0 ) || ( pVideo->fieldMode == 2 ) )
// frame picture or first field of a field picture
{
compute = VideoGetBBL();
if ( compute < ( 4 * pVideo->vbvDelay / 5) ) // 0.8 is 4/5 !
// bit buffer level is not high enough for the next
// picture: wait !!!
{ // we stop the current decoding
// process for two fields
VideoEnableDecoding(OFF);
pVideo->needDataInBuff = pVideo->currField;
}
}
/********************************************************************/
/*
* We put the decoder in wait mode on DSYNC: EXE bit reset
* into INS.
*/
/*
* In normal case the DSYNC interrupt is quickly followed
* by a
*/
/*
* Header Hit int. during which the next INS is written
* with EXE=1.
*/
/*
* If for any reason the header hit is delayed, the STi3500
* will
*/
/* see the notEXE and stay in WAIT mode without crashing... */
/* this can typically appear if the bit buffer gets empty. */
/********************************************************************/
if ( !pVideo->needDataInBuff )
{
VideoWaitDec (); // put decoder in Wait mode
pVideo->NextInstr.Exe = 0;
// reset EXE bit.
}
/* update the display frame pointer for the next VSYNC */
if ( ( pVideo->fieldMode == 0 ) || ( pVideo->fieldMode == 2 ) )
// frame picture or first field of a field picture
{
pVideo->pCurrDisplay = pVideo->pNextDisplay;
// preset the VSYNC counter
pVideo->pictDispIndex = 0 - ( 2 * pVideo->decSlowDown );
if ( pVideo->DecodeMode != PlayModeSlow)
pVideo->decSlowDown = 0; /* allows to do the repeat
* function */
BoardWriteVideo( DFP, (BYTE)( pVideo->pCurrDisplay->buffer >> 8 ) );
BoardWriteVideo( DFP + 1, (BYTE)( pVideo->pCurrDisplay->buffer & 0xFF ) );
pVideo->displaySecondField = 0;
VideoChooseField ();
}
VideoSetPSV (); // update the next pan vector
// frame picture or second field of field picture */
// if ( ( pVideo->VideoState == StatePause ) && ( pVideo->fieldMode != 2 ) )
// pVideo->pictureDecoded = 1;
// to know that in step by step, the picture is decoded
}
}
/******************************************************/
/** HEADER HIT INTERRUPT **/
/******************************************************/
if ( ( pVideo->intStatus & HIT ) != 0 )
// Test Header hit interrupt
{
WORD temp = 0;
pVideo->intStatus = pVideo->intStatus & ~HIT;
// clear HIT bit
while ( VideoHeaderFifoEmpty())
/* Header fifo not available */
{
temp++;
if ( temp == 0xFFFF )
{
if ( !pVideo->errCode )
pVideo->errCode = BUF_EMPTY;
SetErrorCode(ERR_HEADER_FIFO_EMPTY);
break;
}
}
/* Waiting... */
compute = BoardReadVideo(HDF);
//compute = BoardReadVideo ( HDF );
/* load MSB */
pVideo->hdrPos = 0; /* start code is MSB */
if ( compute == 0x01 )
{
pVideo->hdrPos = 8; /* start code value is in LSB */
pVideo->hdrNextWord = (WORD)BoardReadVideo(HDF)<<8;//BoardReadVideo ( HDF ) << 8;
ReadHeaderDataFifo ();
/* Result in pVideo->hdrFirstWord */
}
else
{
pVideo->hdrNextWord = 0;
pVideo->hdrFirstWord = BoardReadVideo(HDF);
pVideo->hdrFirstWord = pVideo->hdrFirstWord | ( compute << 8 );
}
/*
* on that point the start code value is always the MSByte of
* pVideo->hdrFirstWord
*/
switch ( pVideo->hdrFirstWord & 0xFF00 )
{
DWORD buf_control;
DWORD size_of_pict;
case SEQ:
VideoSequenceHeader ();
/* Restart Header Search */
BoardWriteVideo ( VID_HDS, HDS );
break;
case EXT:
VideoExtensionHeader ();
BoardWriteVideo ( VID_HDS, HDS );
/* Restart Header Search */
break;
case GOP:
VideoGopHeader ();
BoardWriteVideo ( VID_HDS, HDS );
/* Restart Header Search */
break;
case PICT:
VideoPictureHeader ();
// This part of the code
// Computes the size of last picture
// and substracts it to lastbuffer level
// This allows to track if pipe/scd are misalined
buf_control = ReadSCDCount ();
if ( pVideo->LastScdCount > buf_control )
size_of_pict = ( 0x1000000L - pVideo->LastScdCount ) + buf_control;
else
size_of_pict = buf_control - pVideo->LastScdCount;
pVideo->LastScdCount = buf_control;
if ( pVideo->fastForward )
pVideo->LastPipeReset = 3;
pVideo->LastBufferLevel -= ( WORD ) ( size_of_pict >> 7 );
//End of misalined pb tracking
/* don't restart header search !!! */
if ( pVideo->skipMode ) // restart search only if we
// skip this picture
{
BoardWriteVideo ( VID_HDS, HDS );
/* Restart Header Search */
}
break;
case USER: // We don't care about user
// fields
BoardWriteVideo ( VID_HDS, HDS );
/* Restart Header Search */
break;
case SEQ_END: // end of sequence code
compute = (WORD)BoardReadVideo ( ITS ) << 8;
// this start code can be back to back with next one
compute = ( compute | BoardReadVideo ( ITS + 1 ) );
// in such case the HDS bit can be set
pVideo->intStatus = ( pVideo->intStatus | compute ) & pVideo->intMask;
if ( !( pVideo->intStatus & HIT ) )
{
BoardWriteVideo ( VID_HDS, HDS );
/* Restart Header Search */
}
break;
case SEQ_ERR: // the chip will enter the
// automatic error concealment
// mode
compute = (WORD)BoardReadVideo ( ITS ) << 8;
// this start code can be back to back with next one
compute = ( compute | BoardReadVideo ( ITS + 1 ) );
// in such case the HDS bit can be set
pVideo->intStatus = ( pVideo->intStatus | compute ) & pVideo->intMask;
if ( !( pVideo->intStatus & HIT ) )
{
BoardWriteVideo ( VID_HDS, HDS );
/* Restart Header Search */
}
break;
default:
if ( !pVideo->errCode )
pVideo->errCode = S_C_ERR;
SetErrorCode(ERR_UNKNOWN_SC);
// non video start code
break;
}
} // end of header hit interrupt
/******************************************************/
/** BIT BUFFER FULL INTERRUPT **/
/******************************************************/
if ( ( pVideo->intStatus & BBF ) != 0x0 )
/* Bit buffer full */
{
pVideo->intStatus = pVideo->intStatus & ~BBF;
// clear BBF bit
if ( pVideo->vbvReached == 1 ) /* bit buffer level too high */
{
if ( !pVideo->errCode )
pVideo->errCode = FULL_BUF; /* mention of the error */
SetErrorCode(ERR_BIT_BUFFER_FULL);
VideoWaitDec (); // put decoder in Wait mode
pVideo->NextInstr = pVideo->ZeroInstr;
}
else
{
WORD BitBufferLevel;
BitBufferLevel = pVideo->VideoBufferSize - 2;
VideoSetBBThresh(BitBufferLevel);
pVideo->intMask = PID | SER | PER | PSD | BOT | TOP | BBE | HIT;
/* enable all interrupts that may be used */
BoardReadVideo ( ITS );
BoardReadVideo ( ITS + 1);
// to clear previous TOP VSYNC flag
pVideo->NextInstr.Exe = 1;; // decoding will start on
// next "good" Vsync */
pVideo->VsyncNumber = 0;
pVideo->pictDispIndex = 1;
pVideo->pCurrDisplay->nb_display_field = 1;
pVideo->vbvReached = 1;
pVideo->FistVsyncAfterVbv = NOT_YET_VST;
}
}
//*****************************************************/
//* pipeline ERROR **/
//*****************************************************/
// The pipeline reset is made here by software */
// It is also possible to enable the automatic */
// Pipeline reset by setting bit EPR of CTL reg. */
// This could be done in the Reset3500 routine */
// In this case the pipeline error interrupt is */
// only used as a flag for the external micro. */
//*****************************************************/
if ( ( pVideo->intStatus & PER ) != 0x0 )
{
pVideo->intStatus = pVideo->intStatus & ~PER;
// clear PER bit
// VideoPipeReset ( pVideo );
}
/******************************************************/
/** serious ERROR **/
/******************************************************/
if ( ( pVideo->intStatus & SER ) != 0x0 )
{
pVideo->intStatus = pVideo->intStatus & ~SER;
// clear SER bit
VideoPipeReset ();
}
/********************************/
/* bit buffer empty interrupt */
/********************************/
if ( ( pVideo->intStatus & BBE ) != 0x0 )
// bit buffer empty
{
pVideo->intStatus = pVideo->intStatus & ~BBE;
// clear BBE bit
}
/********************************/
/* pipeline idle interrupt */
/********************************/
if ( ( pVideo->intStatus & PID ) != 0x0 )
// pipeline idle
{
//***************************************
// Check If pipe is misalined with scd
// and restart header search if it is
// the case
//***************************************
DWORD NewCd;
DWORD EnterBitBuffer;
WORD NewBbl;
WORD ExpectedBbl;
// clear PID bit
pVideo->intStatus = pVideo->intStatus & ~PID;
/* read BBL level */
NewBbl = VideoGetBBL();
/* Read number of compressed data loaded into the chip */
NewCd = ReadCDCount ();
if ( NewCd < pVideo->LastCdCount )
EnterBitBuffer = ( 0x1000000L - pVideo->LastCdCount ) + NewCd;
else
EnterBitBuffer = ( NewCd - pVideo->LastCdCount );
//Expected Bitbuffer level is Old bbl + what enterred - what left
//pVideo->LastBufferLevel holds Old bbl + what enterred and has been
// updated in picture hit interrupt.
ExpectedBbl = (WORD)(pVideo->LastBufferLevel + ( EnterBitBuffer >> 8 ) - 2);
if ( pVideo->LastPipeReset == 0 )
{
/* BBL is lower than it should be !!! */
if ( NewBbl < ExpectedBbl )
{
/* here we force manually a new header search because */
/* the pipeline is supposed to have skipped a picture */
/* i.e. the start code detector and the pipeline are */
/* not synchronised on the same picture */
BoardWriteVideo ( VID_HDS, HDS );
pVideo->LastPipeReset = 1;
}
}
else
{
pVideo->LastPipeReset--;
}
pVideo->LastCdCount = NewCd;
pVideo->LastBufferLevel = NewBbl;
}
/******************************************************/
/** END OF INTERRUPT ROUTINE **/
/******************************************************/
/* common to all interrupts */
/* set interrupt mask to the correct value */
} // end of while
return VideoITOccured;
}
/****************************************************************************/
/* notations of the bits position in pVideo->hdrFirstWord registers are */
/* X for a nibble that must be read */
/* x for a bit that must be read */
/* 0 for a nibble not read */
/* o for a bit not read */
/* example : 0 X xxoo 0 means: bits 15 to 12 not read, */
/* bits 11 to 6 extracted, bits 5 to 0 not read */
/****************************************************************************/
//----------------------------------------------------------------------------
// Read of the header data fifo
//----------------------------------------------------------------------------
/*
returns the next word(16 bits) of the
Header data Fifo into pVideo->hdrFirstWord variable
*/
static void NEARAPI ReadHeaderDataFifo (void)
{
WORD i = 0;
while ( VideoHeaderFifoEmpty()) /* Header fifo not available */
{
i++;
if (i == 0xFFFF) {
if ( !pVideo->errCode )
pVideo->errCode = BUF_EMPTY;
SetErrorCode(ERR_BIT_BUFFER_EMPTY);
break;
}
} /* Waiting... */
pVideo->hdrFirstWord = BoardReadVideo(HDF);
if (pVideo->hdrPos == 8) {
pVideo->hdrFirstWord = pVideo->hdrNextWord | pVideo->hdrFirstWord;
pVideo->hdrNextWord = BoardReadVideo(HDF) << 8;
}
else
{
pVideo->hdrFirstWord = pVideo->hdrFirstWord << 8;
pVideo->hdrFirstWord = BoardReadVideo(HDF) | pVideo->hdrFirstWord;
}
}
//----------------------------------------------------------------------------
// Routine associating the PTS values with each picture
//----------------------------------------------------------------------------
static void NEARAPI VideoAssociatePTS (void)
{
pVideo->pDecodedPict->validPTS = VideoIsValidPTS( );
if(pVideo->pDecodedPict->validPTS) {
pVideo->pDecodedPict->dwPTS = BoardReadVideoPTS( );
}
}
//----------------------------------------------------------------------------
// Read of the next start code in the bit stream
//----------------------------------------------------------------------------
/*
This routine is used at the end of the picture header
when the Start Code Detection mechanism is not used
*/
static void NEARAPI VideoNextStartCode (WORD i)
{
long temp = 0;
if ( i )
temp = pVideo->hdrFirstWord & 0xFF; // use LSB of pVideo->hdrFirstWord
while ( temp == 0 )
{
ReadHeaderDataFifo (); // read next 16 bits
if ( pVideo->errCode )
{
i = 3;
break;
}
temp = ( temp << 16 ) | pVideo->hdrFirstWord;
i = i + 2;
}
if ( i < 3 ) { // A start code is not found: bit stream error !!
pVideo->errCode = PICT_HEAD;
SetErrorCode(ERR_PICTURE_HEADER);
}
else
{
if ( ( temp & 0xFFFFFF00L ) == 0x00000100L ) // this is a start code
{
if ( !pVideo->hdrPos ) // there is nothing into
// pVideo->hdrNextWord
{
pVideo->hdrPos = 8;
pVideo->hdrNextWord = ( pVideo->hdrFirstWord & 0xFF ) << 8;
ReadHeaderDataFifo ();
}
else
{ // pVideo->hdrPos = 8: the next
// byte is into pVideo->hdrNextWord
pVideo->hdrFirstWord = ( pVideo->hdrFirstWord << 8 ) | ( pVideo->hdrNextWord >> 8 );
pVideo->hdrPos = 0;
}
}
else if ( ( temp & 0xFFFFFFFFL ) == 0x00000001L ) // this is a start code
{
ReadHeaderDataFifo ();
}
else { // temp does not contain a start code : bit stream error !
if ( !pVideo->errCode )
pVideo->errCode = PICT_HEAD;
SetErrorCode(ERR_PICTURE_HEADER);
}
}
i = BoardReadVideo ( ITS ) << 8; // allows to clear the Header hit bit
i = ( i | BoardReadVideo ( ITS + 1 ) ) & 0xFFFE; // allows to clear the
// Header hit bit
pVideo->intStatus = ( pVideo->intStatus | i ) & pVideo->intMask;
/* if no bit stream error, we leave the routine with the start code into pVideo->hdrFirstWord as XX00 */
}
//----------------------------------------------------------------------------
// SEQUENCE START CODE
//----------------------------------------------------------------------------
static void NEARAPI VideoSequenceHeader(void)
{
DWORD compute, i;
/* default intra quantization matrix */
// default Non intra quantization matrix, All coefs = 16
for (i = 0 ; i < QUANT_TAB_SIZE ; i++)
DefNonIntQuant[i] = 16;
seq_occured = 1; // mention to the picture header that a sequence has occured
// in order to reset the next pan offsets.
/* Horizontal picture size is 12 bits: 00XX + X000 */
pVideo->StreamInfo.horSize = ( pVideo->hdrFirstWord << 4 ) & 0xFFF; // extract 8 MSB
ReadHeaderDataFifo ();
pVideo->StreamInfo.horSize = pVideo->StreamInfo.horSize | ( pVideo->hdrFirstWord >> 12 ); // 4 LSB of horizontal
// size
/* Vertical picture size is 12 bits: 0XXX */
pVideo->StreamInfo.verSize = pVideo->hdrFirstWord & 0xFFF; // 12 LSB of Vertical picture
// size
/* pixel aspect ratio is 4 bits: X000 */
ReadHeaderDataFifo ();
pVideo->StreamInfo.pixelRatio = ( pVideo->hdrFirstWord >> 12 ) & 0xF;
/* frame rate is 4 bits: 0X00 */
pVideo->StreamInfo.frameRate = ( pVideo->hdrFirstWord >> 8 ) & 0xF;
pVideo->StreamInfo.displayMode = 1; // 60 Hz interlaced display
pVideo->BufferA = BUFF_A_NTSC;
pVideo->BufferB = BUFF_B_NTSC;
pVideo->BufferC = BUFF_C_NTSC;
switch ( pVideo->StreamInfo.frameRate )
{
case 1: // picture rate is 23.976 Hz:
break; // display in 3:2 pull-down at
// 59.94 Hz interlaced if MPEG1
case 2: // picture rate is 24 Hz:
break; // display in 3:2 pull-down at
// 60 Hz interlaced if MPEG1
case 3: // picture rate is 25 Hz:
// display 50 Hz interlaced
pVideo->StreamInfo.displayMode = 0;
pVideo->BufferA = BUFF_A_PAL;
pVideo->BufferB = BUFF_B_PAL;
pVideo->BufferC = BUFF_C_PAL;
break;
case 4: // picture rate is 29.97 Hz
break;
case 5: // picture rate is 30 Hz
break;
default:
SetErrorCode(ERR_FRAME_RATE_NOT_SUPPORTED);
if ( !pVideo->errCode )
pVideo->errCode = FRAME_RATE; /* frame rate not supported by the board */
break;
}
/* bit rate is 18 bits: 00XX + XX xxoo 0 */
pVideo->StreamInfo.bitRate = (long) pVideo->hdrFirstWord;
pVideo->StreamInfo.bitRate = ( pVideo->StreamInfo.bitRate << 10 ) & 0x3FC00L;
ReadHeaderDataFifo();
pVideo->StreamInfo.bitRate = pVideo->StreamInfo.bitRate | ( pVideo->hdrFirstWord >> 6 );
/* bit rate is 18 bits only for MPEG1 bit streams */
if ( !pVideo->StreamInfo.modeMPEG2 )
{
long tota = 400L;
pVideo->StreamInfo.bitRate = pVideo->StreamInfo.bitRate * tota; /* bit rate is a multiple of 400
* bits/s */
}
/*
* for MPEG2 bit streams bit rate is 30 bits: 12 more bits in
* sequence extension
*/
/* marker bit: 00 ooxo 0 : just skipped ... */
/* pVideo->vbvBufferSize is 10 bits : 00 ooox X + X xooo 00 */
pVideo->vbvBufferSize = ( pVideo->hdrFirstWord << 5 ) & 0x3E0;
ReadHeaderDataFifo ();
pVideo->vbvBufferSize = pVideo->vbvBufferSize | ( pVideo->hdrFirstWord >> 11 );
// if( (!pVideo->StreamInfo.modeMPEG2) && ((pVideo->vbvBufferSize*8) > BUF_FULL) )
// if (!pVideo->errCode) pVideo->errCode = SMALL_BUF; /* Buffer size too small to decode the bit stream */
// for MPEG2 bit streams pVideo->vbvBufferSize is 15 bits: 5 more bits in
// sequence extension */
// constrained flag is 1 bit: 0 oxoo 00 : just skipped... */
// load intra quant table bit : 0 ooxo 00 */
if ( ( pVideo->hdrFirstWord & 0x200 ) != 0 ) // Test load intra quantizer
// matrix */
{
// Read Non Default Intra Quant Table
for ( i = 0; i < (QUANT_TAB_SIZE/2) ; i++)
{
compute = pVideo->hdrFirstWord << 7;
ReadHeaderDataFifo ();
compute = compute | ( pVideo->hdrFirstWord >> 9 );
QuantTab[2*i] = (BYTE)( compute >> 8 );
QuantTab[2*i+1] = (BYTE)( compute & 0xFF );
}
// Load Intra Quant Tables
VideoLoadQuantTables(TRUE , QuantTab );
pVideo->defaultTbl = pVideo->defaultTbl & 0xE; // bit 0 = 0 : no default table
// in the chip */
}
else if ( !( pVideo->defaultTbl & 0x1 ) ) // Load default intra matrix */
{
VideoLoadQuantTables(TRUE , DefIntQuant );
pVideo->defaultTbl++; // bit 0 = 1 default intra table
// is in the chip */
}
// load non intra quant table bit : 0 ooox 00 */
if ( ( pVideo->hdrFirstWord & 0x100 ) != 0 ) // Test load non intra quantizer
// matrix */
{ // Load non intra quantizer
// matrix */
for ( i = 0; i < (QUANT_TAB_SIZE/2) ; i++)
{
compute = pVideo->hdrFirstWord & 0xFF;
QuantTab[2*i] = (BYTE)( compute );
ReadHeaderDataFifo ();
compute = ( pVideo->hdrFirstWord >> 8 ) & 0xFF;
QuantTab[2*i+1] = (BYTE)( compute );
}
VideoLoadQuantTables(FALSE , QuantTab );
pVideo->defaultTbl = pVideo->defaultTbl & 0xD; // bit 1 = 0 : no default
// non-intra matrix */
}
else if ( !( pVideo->defaultTbl & 0x2 ) ) // default non intra table not
// in the chip */
{
VideoLoadQuantTables(FALSE , DefNonIntQuant );
pVideo->defaultTbl = pVideo->defaultTbl | 0x2; // bit 1 = 1: default non intra
// table into the chip */
}
if ( ( !pVideo->StreamInfo.modeMPEG2 ) && ( pVideo->notInitDone ) ) // initialisation of the
// frame size is only done
// once
{
VideoSetPictureSize ();
// BoardVideoSetDisplayMode ( (BYTE)(pVideo->StreamInfo.displayMode));
VideoInitXY ();
pVideo->notInitDone = 0;
}
// in case of MPEG2 bit streams the initialisation can only be done
// after sequence extension */
// end of sequence header analysis */
}
//----------------------------------------------------------------------------
// EXTENSION START CODE
//----------------------------------------------------------------------------
// interrupt only enabled after sequence or GOP start code */
static void NEARAPI VideoExtensionHeader(void)
{
WORD comput1;
DWORD temp;
// extension field is 4 bits: 00X0 */
switch ( pVideo->hdrFirstWord & 0xF0 )
{
//**********************************************************/
// SEQUENCE EXTENSION */
//**********************************************************/
case SEQ_EXT: // sequence extension field
// always present in MPEG2
if ( !pVideo->StreamInfo.modeMPEG2 ) // automatic detection of the
// standard
{
DWORD tota = 400L;
pVideo->StreamInfo.bitRate = pVideo->StreamInfo.bitRate / tota; // bit rate was mult. by
// 400 in sequence header
// if pVideo->StreamInfo.modeMPEG2 = 0
pVideo->StreamInfo.modeMPEG2 = 1;
pVideo->NextInstr.Mp2 = 1;
pVideo->notInitDone = 1;
}
/* one bit reserved for future use : 000xooo */
/* Profile indication: 000oxxx */
comput1 = pVideo->hdrFirstWord & 0x7;
if ( ( comput1 != 4 ) && ( comput1 != 5 ) ) { // main profile Id =
// 100, simple profile =
// 101
SetErrorCode(ERR_PROFILE_NOT_SUPPORTED);
if ( !pVideo->errCode )
pVideo->errCode = MAIN_PROF;// not simple or main profile bitstream
}
/* Level indication: X000 */
ReadHeaderDataFifo ();
comput1 = pVideo->hdrFirstWord & 0xF000;
if ( ( comput1 != 0x8000 ) && ( comput1 != 0xA000 ) ) {// main level Id = 1000,
// low level = 1010
if ( !pVideo->errCode )
pVideo->errCode = MAIN_PROF;// not low or main level bitstream
SetErrorCode(ERR_LEVEL_NOT_SUPPORTED);
}
/* non interlaced sequence bit : 0 xooo 00 */
pVideo->StreamInfo.progSeq = 0;
if ( ( pVideo->hdrFirstWord & 0x0800 ) ) // non-interlaced frames
pVideo->StreamInfo.progSeq = 1;
/* chroma format is 2 bits: 0 oxxo 00 */
// test if 4.1.1 chroma format
if ( ( pVideo->hdrFirstWord & 0x600 ) != 0x200 ) {
if ( !pVideo->errCode )
pVideo->errCode = CHROMA; // chroma format not supported
SetErrorCode(ERR_CHROMA_FORMAT_NOT_SUPPORTED);
}
/* horizontal size extension is 2 bits : 0 ooox xooo 0 */
comput1 = ( pVideo->hdrFirstWord & 0x180 ); // extract 2 MSb of
// horizontal picture size
pVideo->StreamInfo.horSize = pVideo->StreamInfo.horSize | ( comput1 << 3 );
/* vertical size extension is 2 bits: 00 oxxo 0 */
comput1 = ( pVideo->hdrFirstWord & 0x60 ); // extract 2 MSb of
// vertical picture size
pVideo->StreamInfo.verSize = pVideo->StreamInfo.verSize | ( comput1 << 5 );
/* bit rate extension is 12 bits: 00 ooox X + X xxxo 00 */
temp = ( pVideo->hdrFirstWord & 0x1F ) << 25;
ReadHeaderDataFifo ();
temp = ( ( pVideo->hdrFirstWord & 0xFE00 ) << 9 ) | temp;
pVideo->StreamInfo.bitRate = temp | pVideo->StreamInfo.bitRate;
if ( pVideo->StreamInfo.bitRate > 37500L ) // more than 15 Mbits/s
{
if ( !pVideo->errCode )
pVideo->errCode = HIGH_BIT_RATE; // put a warning only for the eval board
SetErrorCode(ERR_BITRATE_TO_HIGH);
}
else
{
long tota = 400L;
pVideo->StreamInfo.bitRate = pVideo->StreamInfo.bitRate * tota; /* bit rate is a multiple of 400 bits/s */
}
/* marker bit: 0 ooox 00 : just skipped */
/* pVideo->vbvBufferSize_extension is 8 bits : 00 XX */
pVideo->vbvBufferSize = pVideo->vbvBufferSize | ( ( pVideo->hdrFirstWord & 0xFF ) << 10 );
// frame rate extension not tested here */
if ( pVideo->notInitDone )
{
VideoSetPictureSize ();
// BoardVideoSetDisplayMode ( (BYTE)(pVideo->StreamInfo.displayMode) );
VideoInitXY ();
pVideo->notInitDone = 0;
}
break;
// end of sequence extension field */
//**********************************************************/
// SEQUENCE DISPLAY EXTENSION */
//**********************************************************/
case SEQ_DISP: // sequence display extension
// field
pVideo->seqDispExt = 1;
/* video format is 3 bits: 00 0 xxxo : not used... */
/* colour description is 1 bit : 00 0 ooox */
if ( pVideo->hdrFirstWord & 0x1 )
{
ReadHeaderDataFifo ();
/* colour primaries is 8 bits: XX 00 : not used... */
/*
* transfer characteristics is 8 bits: 00 XX : not
* used...
*/
ReadHeaderDataFifo ();
/* matrix coefficients is 8 bits: XX 00: not used... */
/*
* pan_horizontal_dimension is 14 bits: 00 XX + X xxoo
* 00
*/
pVideo->StreamInfo.horDimension = ( pVideo->hdrFirstWord & 0xFF ) << 6;
ReadHeaderDataFifo ();
pVideo->StreamInfo.horDimension = pVideo->StreamInfo.horDimension | ( ( pVideo->hdrFirstWord & 0xFC00 ) >> 10 );
/* skip marker bit : 0ooxo 00 */
/*
* pan_vertical_dimension is 14 bits: 0 ooox XX + X
* xooo 00
*/
pVideo->StreamInfo.verDimension = ( pVideo->hdrFirstWord & 0x1FF ) << 5;
ReadHeaderDataFifo ();
pVideo->StreamInfo.verDimension = pVideo->StreamInfo.verDimension | ( ( pVideo->hdrFirstWord & 0xF800 ) >> 11 );
}
else
{
/* pan_horizontal_dimension is 14 bits: XX X xxoo */
ReadHeaderDataFifo ();
pVideo->StreamInfo.horDimension = ( pVideo->hdrFirstWord & 0xFFFC ) >> 2;
/* skip marker bit : 00 0 ooxo */
/*
* pan_vertical_dimension is 14 bits: 00 0 ooox + XX X
* xooo
*/
pVideo->StreamInfo.verDimension = ( pVideo->hdrFirstWord & 0x1 ) << 13;
ReadHeaderDataFifo ();
pVideo->StreamInfo.verDimension = pVideo->StreamInfo.verDimension | ( ( pVideo->hdrFirstWord & 0xFFF8 ) >> 3 );
}
/* pVideo->StreamInfo.horDimension and pVideo->StreamInfo.verDimension represent the area of the decoded */
/* picture that will be displayed on the full screen */
/*
* this area should be interpolated to the size of the
* display
*/
/*
* this is not possible vertically. Horizontally the SRC is
* used
*/
/* to deliver 720 pixels */
if ( pVideo->StreamInfo.horDimension < pVideo->StreamInfo.horSize )
{
DWORD lsr;
BYTE i;
// lsr = 256 * (pVideo->StreamInfo.horSize-4) / (display size - 1)
lsr = ( 256 * ( long ) ( pVideo->StreamInfo.horDimension - 4 ) ) / 719;
if ( lsr < 32 )
lsr = 32;
i = BoardReadVideo ( LSO );
BoardWriteVideo ( LSO, i ); // programmation of the
// SRC
BoardWriteVideo ( LSR, (BYTE)lsr );
i = BoardReadVideo ( CSO );
BoardWriteVideo ( CSO,i);
if ( !pVideo->useSRC ) // flag enabling or not the use of SRC
{
VideoSRCOn ();
}
}
break;
default: /* other extension fields are
* not tested here */
break; /* extensions related to the
* picture are tested at the end
* of the picture header */
}
}
//----------------------------------------------------------------------------
// G.O.P. START CODE
//----------------------------------------------------------------------------
/* GOP informations are extracted but not used ! */
static void NEARAPI VideoGopHeader(void)
{
WORD compute;
pVideo->hdrHours = (BYTE) ( pVideo->hdrFirstWord >> 2 ) & 0x1F; /* Skip drop frame flag */
compute = ( pVideo->hdrFirstWord << 4 ) & 0x3F;
ReadHeaderDataFifo ();
pVideo->hdrMinutes = (BYTE)(( pVideo->hdrFirstWord >> 12 ) | compute);
pVideo->hdrSeconds = (BYTE)( pVideo->hdrFirstWord >> 5 ) & 0x3F;
compute = ( pVideo->hdrFirstWord << 1 ) & 0x3F;
ReadHeaderDataFifo ();
pVideo->pictTimeCode = (BYTE)(( pVideo->hdrFirstWord >> 15 ) | compute);
if ( pVideo->StreamInfo.countGOP != 0 )
pVideo->StreamInfo.countGOP = pVideo->StreamInfo.countGOP | 0x100; /* Second Gop */
// to avoid any confusion between gops when testing the pVideo->decSlowDownral
// ref. for display
pVideo->GOPindex = pVideo->GOPindex + 0x4000;
}
//----------------------------------------------------------------------------
// PICTURE START CODE
//----------------------------------------------------------------------------
static void NEARAPI VideoPictureHeader(void)
{
WORD comput1;
DWORD temp;
// Determine which picture variable can be used to store the next
// decoding parameters.
// We use the next variable in pVideo->pictArray table, because the
// corresponding frame
// has been already displayed.
// The decoded picture buffer is not incremented if we are on a
// second field picture
// or if we have decided to skip the previous picture.
// The first_field attribute is not changed on the second field of
// 2 field pictures.
if ( ( !pVideo->skipMode ) && ( pVideo->fieldMode < 2 ) )
{
WORD i; // increment picture buffer
for ( i = 0; i < 4; i++ )
if ( pVideo->pictArray[i].tempRef == 1025 )
{
pVideo->pDecodedPict = &pVideo->pictArray[i];
break;
}
// We always initialise first_field to TOP (default for MPEG1).
// It could be changed in case of 3:2 pull-down in MPEG1
// or into the picture coding extension for MPEG2 bit stream.
pVideo->pDecodedPict->first_field = TOP;
}
pVideo->currPictCount++;
if ( pVideo->currPictCount == 6 )
{
// Unforce the border color and start displaying
pVideo->currDCF = pVideo->currDCF | 0x20;
BoardWriteVideo ( DCF, 0 );
BoardWriteVideo ( DCF + 1, (BYTE)(pVideo->currDCF));
}
// write the latest transmitted pan offsets into the new pVideo->pictArray
// variable
// those offsets may be changed in the picture pan and scan
// extension...
// for MPEG1 bit stream they remain to zero.
// if a sequence had occured since the last decoded picture the pan
// offsets are all reset to 0
if ( seq_occured )
{
pVideo->latestPanHor = 0;
pVideo->latestPanVer = 0;
}
for ( comput1 = 0; comput1 < 3; comput1++ )
{
pVideo->pDecodedPict->pan_hor_offset[comput1] = pVideo->latestPanHor;
pVideo->pDecodedPict->pan_vert_offset[comput1] = pVideo->latestPanVer;
}
seq_occured = 0;
/* start analysis of the picture header */
comput1 = pVideo->hdrFirstWord << 2;
ReadHeaderDataFifo (); /* read next 16 bits */
/* picture pVideo->decSlowDownral reference is 10 bits: 00XX + xxoo 000 */
pVideo->pDecodedPict->tempRef = comput1 | ( pVideo->hdrFirstWord >> 14 ) | pVideo->GOPindex;
/* picture type is 3 bits : ooxx xooo 00 */
pVideo->pDecodedPict->pict_type = (BYTE)( pVideo->hdrFirstWord >> 11 ) & 0x7; // set picture type of
// decoded picture
pVideo->NextInstr.Pct =(BYTE) (pVideo->pDecodedPict->pict_type)&0x3; /* Picture type in instruction register */
// Only 2 bits are stored
if ( pVideo->skipMode ) // We are on the second picture:
// the previous one will be
// skipped
pVideo->skipMode++;
else // !pVideo->skipMode. We skip a picture if
// pVideo->fastForward = 1 and on B pictures
// only
if ( pVideo->fastForward && ( pVideo->fieldMode < 2 ) )
{
pVideo->NotSkipped++;
if ( ( pVideo->pDecodedPict->pict_type == 3 ) // we are on a B picture
|| ( ( pVideo->NotSkipped > 5 ) && ( pVideo->pDecodedPict->pict_type == 2 ) ) ) // we are on a P picture
// we are on a B
// picture
{
pVideo->NotSkipped = 0;
pVideo->skipMode = 1; // this picture will be skipped
}
}
/* pVideo->vbvDelay is 16 bits: O oxxx XX + X xooo OO */
comput1 = pVideo->hdrFirstWord << 5; /* VBV delay is 16 bits */
ReadHeaderDataFifo (); /* read next 16 bits */
comput1 = comput1 | ( pVideo->hdrFirstWord >> 11 );
if (( comput1 == 0 )||( comput1 >= 0x3000 ))
// 0x0 means that the pVideo->vbvDelay is not compliant with MPEG !
// 0xFFFF variable bitrate
comput1 = 0x3000; // we force it to an average
// pVideo->vbvDelay ...
temp = ( ( long ) comput1 * ( pVideo->StreamInfo.bitRate / ( 2048 ) ) ) / 90000L; /* 2048 = 8*256 ! */
if ( temp < 0x20 )
temp = 0x20;
if ( temp > 0x330 )
temp = 0x330;
pVideo->vbvDelay = (WORD)temp;
if ( !pVideo->vbvReached ) /* BBT set to vbv value for the
* first picture */
{
VideoSetBBThresh((WORD)temp);
pVideo->intMask = 0x8; /* Enable buffer full interrupts */
}
temp = 10; /* number of bits - 1 not
* analysed in pVideo->hdrFirstWord */
if ( pVideo->StreamInfo.countGOP < 0x100 ) /* To init the GOP structure */
{ /* this is only done for display
* of the GOP structure */
if ( pVideo->StreamInfo.countGOP < 28 )
{
if ( pVideo->pDecodedPict->pict_type == 1 ) /* I picture */
pVideo->StreamInfo.firstGOP[pVideo->StreamInfo.countGOP] = 'I';
else if ( pVideo->pDecodedPict->pict_type == 2 ) /* P picture */
pVideo->StreamInfo.firstGOP[pVideo->StreamInfo.countGOP] = 'P';
else if ( pVideo->pDecodedPict->pict_type == 3 ) /* B picture *//* B
* picture */
pVideo->StreamInfo.firstGOP[pVideo->StreamInfo.countGOP] = 'B';
else
pVideo->StreamInfo.firstGOP[pVideo->StreamInfo.countGOP] = 'D'; /* D picture */
pVideo->StreamInfo.firstGOP[pVideo->StreamInfo.countGOP + 1] = 0;
}
pVideo->StreamInfo.countGOP++;
}
/* P or B picture forward vectors extraction */
if ( ( pVideo->pDecodedPict->pict_type == 2 ) ||
( pVideo->pDecodedPict->pict_type == 3 ) ) /* P or B picture */
{
/* full_pixel_forward_vector is one bit: 0 oxoo 00 */
if ( ( pVideo->hdrFirstWord & 0x400 ) != 0 )
pVideo->NextInstr.Ffh = 0x8; //Msb of FFH is 1
else
pVideo->NextInstr.Ffh = 0;
/* forward_f_code is 3 bits: 0 ooxx xooo 0 */
comput1 = ( pVideo->hdrFirstWord >> 7 ) & 0x7;
pVideo->NextInstr.Ffh = (BYTE)(pVideo->NextInstr.Ffh | comput1);
temp = 6; /* number of bits - 1 not
* analysed in pVideo->hdrFirstWord */
}
/* B picture backward vector extraction */
if ( pVideo->pDecodedPict->pict_type == 3 ) /* B picture */
{
/* full_pixel_backward_vector is one bit: 00 oxoo 0 */
if ( ( pVideo->hdrFirstWord & 0x40 ) != 0 )
pVideo->NextInstr.Bfh = 0x8;// Msb of Bfh is 1
else
pVideo->NextInstr.Bfh = 0x0;// Msb of Bfh is 0
/* backward_f_code is 3 bits: 00 ooxx xooo */
comput1 = ( pVideo->hdrFirstWord >> 3 ) & 0x0007;
pVideo->NextInstr.Bfh = (BYTE)(pVideo->NextInstr.Bfh | comput1);
temp = 2; /* number of bits - 1 not analysed in pVideo->hdrFirstWord */
}
/*
* If extra informations picture follow they must be extracted from
* the header FIFO
*/
/*
* it is not possible to restart the header search as the next
* header may be a picture one
*/
/*
* the research of the first Slice is made by polling of the header
* fifo
*/
while ( !pVideo->errCode && ( ( pVideo->hdrFirstWord & ( 1 << temp ) ) != 0 ) ) /* extra bit picture = 1 */
{ /* if extra bit picture = 1 , 8 bits follow */
if ( temp <= 8 )
{
ReadHeaderDataFifo ();
temp = temp + 16;
}
temp = temp - 9; /* skip 8 bit of extra
* information picture */
} /* and next extra bit picture
* bit */
/*
* if extension or user data follow they must be extracted from the
* header
*/
pVideo->hdrFirstWord = pVideo->hdrFirstWord & ( ( 1 << temp ) - 1 );
if ( pVideo->hdrFirstWord != 0 ) {/* all remaining bits should be zero */
if ( !pVideo->errCode ) {
pVideo->errCode = PICT_HEAD; /* picture header should be followed by a start code (at least slice) */
}
SetErrorCode(ERR_PICTURE_HEADER);
}
if ( temp > 7 ) /* LSbyte of pVideo->hdrFirstWord is part of the next start code */
VideoNextStartCode (1 ); // already one byte into
// pVideo->hdrFirstWord
else
VideoNextStartCode (0 );
/*
* at this point pVideo->hdrFirstWord contains the next start code value in the
* MSByte
*/
while (!pVideo->errCode) {
if ( ( pVideo->hdrFirstWord & 0xFF00 ) == 0x0100 )
break; // we have reached the slice start code
else if ( ( pVideo->hdrFirstWord & 0xFF00 ) == USER )
VideoUser ();
else if ( ( pVideo->hdrFirstWord & 0xFF00 ) == EXT ) // there can be several
// extension fields
VideoPictExtensionHeader ();
else
break;
}
/*
* We have reached the first Slice start code: all parameters are
* ready for next decoding
*/
/* end of picture header + picture extensions decoding */
VideoAssociatePTS ();
if ( ( !pVideo->fieldMode && ( pVideo->skipMode != 1 ) ) || ( pVideo->fieldMode && ( !pVideo->skipMode || ( pVideo->skipMode == 3 ) ) ) )
{
VideoSetRecons (); // initialise RFP, FFP and BFP
if ( ( pVideo->fieldMode == 0 ) || ( pVideo->fieldMode == 2 ) ) // we are on a frame
// picture or the first
// field of a field
// picture
VideoDisplayCtrl (); // computes the next frame to
// display
}
// implementation of 3:2 pull-down functionality on MPEG1 bit
// streams
// encoded at 23.97Hz or 24 Hz and displayed at 60 Hz.
// 3:2 pull-down on MPEG2 bit streams must be controlled with
// "repeat_first_field" bit
if ( ( !pVideo->StreamInfo.modeMPEG2 ) && ( ( pVideo->StreamInfo.frameRate == 1 ) || ( pVideo->StreamInfo.frameRate == 2 ) ) )
{
if ( pVideo->pCurrDisplay->nb_display_field == 2 )
{ /* same field polarity for the
* next frame */
pVideo->pNextDisplay->nb_display_field = 3;
if ( pVideo->pCurrDisplay->first_field == TOP )
pVideo->pNextDisplay->first_field = TOP;
else
pVideo->pNextDisplay->first_field = BOT;
}
else
{ // previous picture was
// displayed 3 times //
// the first field polarity is
// changing
pVideo->pNextDisplay->nb_display_field = 2;
if ( pVideo->pCurrDisplay->first_field == TOP )
pVideo->pNextDisplay->first_field = BOT;
else
pVideo->pNextDisplay->first_field = TOP;
}
}
if ( pVideo->vbvReached ) // enable next instruction if
// not skipping a picture
{
if ( !pVideo->skipMode ) // no skipped picture
{
pVideo->NextInstr.Exe = 1; // enable EXE bit
pVideo->NextInstr.Skip = 0;
pVideo->currCommand = 0; // reset skip bits
}
else if ( ( pVideo->skipMode == 2 ) && !pVideo->fieldMode )
// skip == 2: We are on the picture following a skipped one
// the instruction can be stored with associated skip bits
// in CMD
{
// HostDirectPutChar('1', BLACK, LIGHTGREEN);
pVideo->currCommand = 0x10; // pVideo->skipMode 1 picture
pVideo->NextInstr.Exe = 1; // enable EXE bit
pVideo->NextInstr.Skip = 1; // skip 1 picture
pVideo->skipMode = 0;
if ( pVideo->DecodeMode != PlayModeFast )
pVideo->fastForward = 0; /* allows to skip only one
* picture */
}
else if ( pVideo->skipMode == 3 )
{
// HostDirectPutChar('2', BLACK, LIGHTGREEN);
// we are on the picture following two skipped fields
pVideo->currCommand = 0x20; // pVideo->skipMode 2 fields
pVideo->NextInstr.Exe = 1; // enable EXE bit
pVideo->NextInstr.Skip = 2; // Skip 2 fields
pVideo->skipMode = 0;
if ( pVideo->DecodeMode != PlayModeFast)
pVideo->fastForward = 0; /* allows to skip only one
* picture */
}
/*
* store the next instruction if we are on the good field to do
* it
*/
if ( ( ( pVideo->pictDispIndex >= pVideo->pCurrDisplay->nb_display_field - 1 ) && !pVideo->fieldMode )
|| ( ( pVideo->fieldMode == 2 ) && ( pVideo->pictDispIndex >= pVideo->pCurrDisplay->nb_display_field - 2 ) ) )
{
if ( pVideo->pNextDisplay->first_field != pVideo->currField )
VideoWaitDec (); // this is the opposite phase:
// put decoder in wait mode
else
// store the next instruction that will be taken into
// account on the next VSYNC
VideoStoreINS (); // store next INS in case where
// enough VSYNC already occured
}
else if ( pVideo->fieldMode == 1 )
VideoStoreINS ();
}
// clear Header hit flag due to polling of extension or user bits
// after the picture start code
// but keep track of possible other interrupt
comput1 = (WORD)BoardReadVideo ( ITS ) << 8;
comput1 = ( comput1 | BoardReadVideo ( ITS + 1 ) ) & 0xFFFE; // allows to clear the
// Header hit bit
pVideo->intStatus = ( pVideo->intStatus | comput1 ) & pVideo->intMask;
}
//----------------------------------------------------------------------------
//
//----------------------------------------------------------------------------
/***************************************************************/
/* This is an extension start code following a picture */
/* In MPEG2 bit stream, this start code can be: */
/* Picture Coding (always) */
/* Quant matrix (optional) */
/* Picture Pan & Scan (optional) */
/* Picture Scalable (optional) : not tested yet */
/***************************************************************/
static void NEARAPI VideoPictExtensionHeader(void)
{
WORD comput1, i;
WORD compute; // need to be int!!
BYTE QuantTab[QUANT_TAB_SIZE];
/* extension Id is 4 bits: 00 X0 */
comput1 = pVideo->hdrFirstWord & 0xF0;
switch ( comput1 )
{
/******* picture coding extension *******/
case PICT_COD:
if ( pVideo->StreamInfo.modeMPEG2 )
{
// clear top field first,forward and backward f_code,
// motion vectors flag
pVideo->NextInstr.Tff = 0; //pVideo->nextInstr1 & 0x403E;
pVideo->NextInstr.Bfh = 0;
pVideo->NextInstr.Ffh = 0;
pVideo->NextInstr.Cmv = 0;
pVideo->NextInstr.Pst = 0;
pVideo->NextInstr.Bfv = 0;
pVideo->NextInstr.Ffv = 0;
pVideo->NextInstr.Dcp = 0;
pVideo->NextInstr.Frm = 0;
pVideo->NextInstr.Qst = 0;
pVideo->NextInstr.Azz = 0;
pVideo->NextInstr.Ivf = 0;
// forward_horizontal_f_code is 4 bits: 00 0X
comput1 = pVideo->hdrFirstWord & 0xF;
pVideo->NextInstr.Ffh = (BYTE)comput1;
// forward_vertical_f_code is 4 bits: X0 00
ReadHeaderDataFifo ();
comput1 = pVideo->hdrFirstWord & 0xF000;
comput1 = comput1 >> 12;
pVideo->NextInstr.Ffv = (BYTE)comput1;
// backward_horizontal_f_code is 4 bits: 0X 00
comput1 = pVideo->hdrFirstWord & 0xF00;
comput1 = comput1 >>8;
pVideo->NextInstr.Bfh = (BYTE)comput1;
// backward_vertical_f_code is 4bits: 00 X0
comput1 = pVideo->hdrFirstWord & 0xF0;
comput1 = comput1 >> 4;
pVideo->NextInstr.Bfv = (BYTE)comput1;
// intra DC precision is 2 bits: 00 0 xx00
comput1 = pVideo->hdrFirstWord & 0x0C;
if ( comput1 == 0xC ) {
if ( !pVideo->errCode ) {
pVideo->errCode = DC_PREC; // 11 bit DC precision
}
SetErrorCode(ERR_INTRA_DC_PRECISION);
}
pVideo->NextInstr.Dcp = (BYTE)( comput1 >> 2 );
// picture structure is 2 bits: 00 0 ooxx
pVideo->pDecodedPict->pict_struc = (BYTE)(pVideo->hdrFirstWord & 0x3);
pVideo->NextInstr.Pst = pVideo->pDecodedPict->pict_struc ;
if ( pVideo->pDecodedPict->pict_struc == 3 ) // frame picture
pVideo->fieldMode = 0;
else // field picture
if ( pVideo->fieldMode == 2 )
pVideo->fieldMode = 1; // second field
else
{
pVideo->fieldMode = 2; // first field
if ( pVideo->pDecodedPict->pict_struc == 2 ) // bottom field is the
// first field
pVideo->pDecodedPict->first_field = BOT;
}
ReadHeaderDataFifo ();
// top_field_first bit is one bit: xooo 0 00
// first_field is already initialised to TOP (beginning
// of picture header)
if ( ( !pVideo->StreamInfo.progSeq ) && ( pVideo->pDecodedPict->pict_struc == 3 ) )
{ // this is an interlaced frame
// picture
if ( ( ( pVideo->hdrFirstWord & 0x8000 ) != 0 ) ) // top field first
pVideo->NextInstr.Tff = 1; // set top_field_first
else // top_field_first already reset
// into pVideo->NextInstr
pVideo->pDecodedPict->first_field = BOT; // bottom field is BOT
// field
}
if ( pVideo->vbvReached == 0 ) // pre-initialise for start of
// the first decoding task
{ // on the good field polarity
pVideo->pictArray[0].first_field = pVideo->pDecodedPict->first_field;
pVideo->pictArray[1].first_field = pVideo->pDecodedPict->first_field;
pVideo->pictArray[2].first_field = pVideo->pDecodedPict->first_field;
pVideo->pictArray[3].first_field = pVideo->pDecodedPict->first_field;
}
// frame_pred_frame_DCT is one bit: oxoo 0 00
if ( ( pVideo->hdrFirstWord & 0x4000 ) != 0 )
pVideo->NextInstr.Frm = 1 ; // frame DCT and 16x16
// prediction
// concealment_motion_vectors flag is one bit: ooxo 0
// 00
if ( pVideo->hdrFirstWord & 0x2000 )
pVideo->NextInstr.Cmv = 1;
// qscale_type is one bit: ooox 0 00
if ( ( pVideo->hdrFirstWord & 0x1000 ) != 0 )
pVideo->NextInstr.Qst = 1; // non linear quantizer
// scale
// intra_vlc_format is one bit: 0 xooo 00
if ( ( pVideo->hdrFirstWord & 0x800 ) != 0 )
pVideo->NextInstr.Ivf = 1; // alternative intra VLC
// table
// alternate scan bit: 0 oxoo 00
if ( ( pVideo->hdrFirstWord & 0x400 ) != 0 )
pVideo->NextInstr.Azz = 1; // alternative scan
// repeat_first_field is one bit: 0 ooxo 00
// A 2 field picture is considered as one picture
// displayed twice
pVideo->pDecodedPict->nb_display_field = 2; // display picture
// during 2 fields
// period
if ( pVideo->pDecodedPict->pict_struc == 3 ) // frame picture
{
if ( pVideo->hdrFirstWord & 0x200 ) // repeat first field
pVideo->pDecodedPict->nb_display_field = 3; // display picture
// during 3 fields
// period
}
// chroma_postprocessing_type is one bit: 0 ooox 00
if ( ( pVideo->hdrFirstWord & 0x100 ) )
{
// use the field repeat mode for chroma vertical
// filter (if enabled)
pVideo->fullVerFilter = pVideo->fullVerFilter | 0x2;
pVideo->currDCF = pVideo->currDCF | 0x2;
}
else
{
// use the line repeat mode for chroma vertical
// filter (if enabled)
pVideo->fullVerFilter = pVideo->fullVerFilter & 0xFFFD;
pVideo->currDCF = pVideo->currDCF & 0xFFFD;
}
BoardWriteVideo ( DCF, 0 );
BoardWriteVideo ( DCF + 1, (BYTE)(pVideo->currDCF));
// progressive_frame is one bit: 00 xooo 0
// composite_display_flag is one bit: 00 oxoo 0
if ( pVideo->hdrFirstWord & 0x40 )
{
// v_axis is one bit: 00 ooxo 0
// field_sequence is 3 bits: 00 ooox xxoo
// sub_carrier is one bit: 00 0 ooxo
ReadHeaderDataFifo ();
// burst_amplitude is 7 bit: 00 0 ooox + X xooo 00
// sub_carrier_phase is 8 bits: 0 oxxx X xooo
// check the 3 lsb of pVideo->hdrFirstWord: next info must be a
// start code
if ( pVideo->hdrFirstWord & 0x7 ) {
if ( !pVideo->errCode ) {
pVideo->errCode = PICT_HEAD;
}
SetErrorCode(ERR_PICTURE_HEADER);
}
VideoNextStartCode (0 );
}
else
{
if ( pVideo->hdrFirstWord & 0x3F ) {
if ( !pVideo->errCode )
pVideo->errCode = PICT_HEAD;
SetErrorCode(ERR_PICTURE_HEADER);
}
VideoNextStartCode (0 );
}
} // end of if pVideo->StreamInfo.modeMPEG2
break;
/******* Quantization table extension *******/
case QUANT_EXT:
/* load_intra_quantizer_matrix is one bit: 00 0 xooo */
if ( ( pVideo->hdrFirstWord & 0x8 ) != 0 )
{ /* Load intra quantizer matrix */
/* two quant values are 16 bits: 00 0 oxxx + XX X xooo */
// Read Non Default Intra Quant Table
for ( i = 0; i < (QUANT_TAB_SIZE/2) ; i++)
{
compute = pVideo->hdrFirstWord << 13;
ReadHeaderDataFifo ();
compute = compute | ( pVideo->hdrFirstWord >> 3 );
QuantTab[2*i] = (BYTE)( compute >> 8 );
QuantTab[2*i+1] = (BYTE)( compute & 0xFF );
}
// Load Intra Quant Tables
VideoLoadQuantTables(TRUE , QuantTab );
pVideo->defaultTbl = pVideo->defaultTbl & 0xE; // bit 0 = 0 : no default table
// in the chip */
}
/* load_non_intra_quantizer_matrix is one bit: 00 0 oxoo */
if ( ( pVideo->hdrFirstWord & 0x4 ) != 0 )
{ /* Load non intra quantizer matrix */
// Read Non Default Non Intra Quant Table
for ( i = 0; i < (QUANT_TAB_SIZE/2) ; i++)
{
compute = pVideo->hdrFirstWord << 14;
ReadHeaderDataFifo ();
compute = compute | ( pVideo->hdrFirstWord >> 2 );
QuantTab[2*i] = (BYTE)( compute >> 8 );
QuantTab[2*i+1] = (BYTE)( compute & 0xFF );
}
// Load Non Intra Quant Tables
VideoLoadQuantTables(FALSE , QuantTab );
pVideo->defaultTbl = pVideo->defaultTbl & 0xD; /* bit 1 = 0 : no default
* non-intra matrix */
}
// check the 2 lsb of pVideo->hdrFirstWord: next info must be a start
// code
if ( pVideo->hdrFirstWord & 0x3 ) {
if ( !pVideo->errCode )
pVideo->errCode = PICT_HEAD;
SetErrorCode(ERR_PICTURE_HEADER);
}
VideoNextStartCode (0 );
break;
/******* picture pan and scan extension *******/
case PICT_PSV:
/**************************************************************/
/* The programmation of the STi3500 offsets is given by: */
/* PSV = integer part of (pVideo->StreamInfo.horSize/2 - pVideo->StreamInfo.horDimension/2 + offset) */
/*
* LSO = fractional part of (pVideo->StreamInfo.horSize/2 - pVideo->StreamInfo.horDimension/2 +
* offset)
*/
/**************************************************************/
/* pan_horizontal_offset_integer is 12 bits: 00 0X + XX 00 */
pVideo->latestPanHor = ( pVideo->hdrFirstWord & 0xF ) << 12;
ReadHeaderDataFifo();
pVideo->latestPanHor = pVideo->latestPanHor | ( ( pVideo->hdrFirstWord & 0xFF00 ) >> 4 );
// pan_horizontal_offset has been multiplied by 16
/* pan_horizontal_offset_sub_pixel is 4 bits: 00 X0 */
/* that are concatenated with the integer part */
pVideo->latestPanHor = pVideo->latestPanHor | ( ( pVideo->hdrFirstWord & 0xF0 ) >> 4 );
// to simplify, the 2 last instructions can be concatenated
// in:
// pVideo->latestPanHor = pVideo->latestPanHor | ((pVideo->hdrFirstWord & 0xFFF0)
// >> 4);
// note that pVideo->latestPanHor is a signed int
// marker bit 00 0 xooo: just skipped
/*
* pan_vertical_offset_integer is 12 bits: 00 0oxxx + XX
* xooo0
*/
pVideo->latestPanVer = ( pVideo->hdrFirstWord & 0x7 ) << 13;
ReadHeaderDataFifo ();
/* pan_vertical_offset_sub_pixel is 4 bits: 00 oxxx xooo */
// they are linked with the integer part
pVideo->latestPanVer = pVideo->latestPanVer | ( ( pVideo->hdrFirstWord & 0xFFF8 ) >> 3 );
// write pan vectors into the decoded picture structure
if ( ( pVideo->fieldMode == 0 ) || ( pVideo->fieldMode == 2 ) ) // frame picture or
// first field
{
pVideo->pDecodedPict->pan_hor_offset[0] = pVideo->latestPanHor;
pVideo->pDecodedPict->pan_vert_offset[0] = pVideo->latestPanVer;
}
else
{ // the offset of second field of
// a field picture is stored
// // on the second offset
// position of the same variable
pVideo->pDecodedPict->pan_hor_offset[1] = pVideo->latestPanHor;
pVideo->pDecodedPict->pan_vert_offset[1] = pVideo->latestPanVer;
}
// marker bit 00 0 oxoo
if ( pVideo->StreamInfo.progSeq ) // a progressive sequence is
// always displayed with the
// same pan and scan offset
{
pVideo->pDecodedPict->pan_hor_offset[1] = pVideo->latestPanHor;
pVideo->pDecodedPict->pan_vert_offset[1] = pVideo->latestPanVer;
pVideo->pDecodedPict->pan_hor_offset[2] = pVideo->latestPanHor;
pVideo->pDecodedPict->pan_vert_offset[2] = pVideo->latestPanVer;
if ( pVideo->hdrFirstWord & 0x3 ) {
if ( !pVideo->errCode )
pVideo->errCode = PICT_HEAD;
SetErrorCode(ERR_PICTURE_HEADER);
}
VideoNextStartCode (0);
}
else if ( !pVideo->StreamInfo.progSeq && ( pVideo->pDecodedPict->pict_struc == 3 ) )
// Frame picture, not progressive sequence: 2 or 3 pan
// offsets
{
// extract second pan and scan offset
/*
* pan_horizontal_offset_integer is 12 bits: 00 0ooxx +
* XX xxoo0
*/
pVideo->latestPanHor = ( pVideo->hdrFirstWord & 0x3 ) << 14;
ReadHeaderDataFifo ();
pVideo->latestPanHor = pVideo->latestPanHor | ( ( pVideo->hdrFirstWord & 0xFFC0 ) >> 2 );
// pan_horizontal_offset has been multiplied by 16
/*
* pan_horizontal_offset_sub_pixel is 4 bits: 00 ooxx
* xxoo
*/
/* that are concatenated with the integer part */
pVideo->latestPanHor = pVideo->latestPanHor | ( ( pVideo->hdrFirstWord & 0x3C ) >> 2 );
pVideo->pDecodedPict->pan_hor_offset[1] = pVideo->latestPanHor;
// marker bit 00 0 ooxo
/*
* pan_vertical_offset_integer is 12 bits: 00 0ooox +
* XX xxxo0
*/
pVideo->latestPanVer = ( pVideo->hdrFirstWord & 0x1 ) << 15;
ReadHeaderDataFifo ();
/*
* pan_vertical_offset_sub_pixel is 4 bits: 00 ooox
* xxxo
*/
// concatenated with the integer part
pVideo->latestPanVer = pVideo->latestPanVer | ( ( pVideo->hdrFirstWord & 0xFFFE ) >> 1 );
pVideo->pDecodedPict->pan_vert_offset[1] = pVideo->latestPanVer;
// marker bit 00 0 ooox
if ( pVideo->pDecodedPict->nb_display_field != 3 )
VideoNextStartCode (0);
else
{ // 3 pan & scan offsets
/* pan_horizontal_offset_integer is 12 bits: XX X0 */
/* pan_horizontal_offset_sub_pixel is 4 bits: 00 0X */
/* they are concatenated in a single word */
ReadHeaderDataFifo ();
pVideo->latestPanHor = pVideo->hdrFirstWord;
pVideo->pDecodedPict->pan_hor_offset[2] = pVideo->latestPanHor;
ReadHeaderDataFifo ();
// marker bit xooo0 00
/*
* pan_vertical_offset_integer is 12 bits: oxxx X X
* xooo
*/
/*
* pan_vertical_offset_sub_pixel is 4 bits: 00 0
* oxxx + xooo 0 00
*/
pVideo->latestPanVer = ( pVideo->hdrFirstWord & 0x7FFF ) << 1;
ReadHeaderDataFifo ();
pVideo->latestPanVer = ( pVideo->hdrFirstWord & 0x8000 ) >> 15;
pVideo->pDecodedPict->pan_vert_offset[2] = pVideo->latestPanVer;
// marker bit oxoo 0 00
if ( pVideo->hdrFirstWord & 0x3FFF ) {
if ( !pVideo->errCode )
pVideo->errCode = PICT_HEAD;
SetErrorCode(ERR_PICTURE_HEADER);
}
VideoNextStartCode (1);
}
}
break;
/******* picture scalable extension *******/
case PICT_SCAL:
pVideo->hdrFirstWord = 0x0100; // not supported: just leave the
// test
break;
/******* other extension start codes *******/
default:
if ( !pVideo->errCode )
pVideo->errCode = BAD_EXT; // extension start code not at the good location !!
SetErrorCode(ERR_BAD_EXTENSION_SC);
break;
} // end of switch
}
//----------------------------------------------------------------------------
// USER HEADER routine
//----------------------------------------------------------------------------
/* this routine just bypasses all the bytes of the user header */
/* and is exit with the next start code value into pVideo->hdrFirstWord XX00 */
static void NEARAPI VideoUser(void)
{
DWORD toto;
WORD i;
toto = pVideo->hdrFirstWord << 16;
ReadHeaderDataFifo ();
toto = toto | pVideo->hdrFirstWord;
while ( ( ( toto & 0x00FFFFFFL ) != 0x00000001L ) &&
( ( toto & 0xFFFFFF00L ) != 0x00000100L ) )
{
toto = toto << 16;
ReadHeaderDataFifo ();
toto = toto | pVideo->hdrFirstWord;
}
if ( ( toto & 0x00FFFFFFL ) == 0x00000001L )
ReadHeaderDataFifo ();
else
{ // pVideo->hdrFirstWord == 01XX
if ( !pVideo->hdrPos ) // there is nothing into pVideo->hdrNextWord
{
pVideo->hdrPos = 8;
pVideo->hdrNextWord = ( pVideo->hdrFirstWord & 0xFF ) << 8;
ReadHeaderDataFifo ();
}
else
{ // pVideo->hdrPos = 8: the next
// byte is into pVideo->hdrNextWord
pVideo->hdrFirstWord = ( pVideo->hdrFirstWord << 8 ) | ( pVideo->hdrNextWord >> 8 );
pVideo->hdrPos = 0;
}
}
i = BoardReadVideo ( ITS ) << 8; // allows to clear the Header
// hit bit
i = ( i | BoardReadVideo ( ITS + 1 ) ) & 0xFFFE; // allows to clear the
// Header hit bit
pVideo->intStatus = ( pVideo->intStatus | i ) & pVideo->intMask;
}
//----------------------------------------------------------------------------
// Set next reconstructed,forward and backward frame pointer
//----------------------------------------------------------------------------
static void NEARAPI VideoSetRecons(void)
{
/************************ I or P pictures ****************************/
if ( pVideo->pDecodedPict->pict_type != 0x3 )
{
if ( pVideo->frameStoreAttr == FORWARD_PRED ) /* pVideo->frameStoreAttr is the prediction
* attribute of BUFF_A */
{
if ( pVideo->fieldMode < 2 )
pVideo->frameStoreAttr = BACKWARD_PRED;
/* Change the prediction attribute */
if ( ( pVideo->fieldMode == 0 ) || ( pVideo->fieldMode == 2 ) )
// frame picture or first field of 2 field pictures
VideoStoreRFBBuf (pVideo->BufferA, pVideo->BufferB, pVideo->BufferB );
// rfp = A, ffp = bfp = B
else // second field of 2 field
// pictures
VideoStoreRFBBuf (pVideo->BufferA, pVideo->BufferB, pVideo->BufferA );
// rfp = A, ffp = B, bfp = A
}
else
{
if ( pVideo->fieldMode < 2 ) // frame picture or 2 field
pVideo->frameStoreAttr = FORWARD_PRED;/* Change the prediction */
if ( ( pVideo->fieldMode == 0 ) || ( pVideo->fieldMode == 2 ) )
// frame picture or first field of 2 field pictures
VideoStoreRFBBuf (pVideo->BufferB, pVideo->BufferA, pVideo->BufferA );
// rfp = B, ffp = bfp = A
else // seond field of 2 field
// pictures
VideoStoreRFBBuf (pVideo->BufferB, pVideo->BufferA, pVideo->BufferB );
// rfp = B, ffp = A, bfp = B
}
}
/************************ B pictures ****************************/
else
{ /* B picture */
if ( pVideo->frameStoreAttr == FORWARD_PRED )
VideoStoreRFBBuf (pVideo->BufferC, pVideo->BufferA, pVideo->BufferB );
else
VideoStoreRFBBuf ( pVideo->BufferC, pVideo->BufferB, pVideo->BufferA );
}
/*********** common for all kind of pictures *********************/
/* test if displayed frame = reconstructed frame */
if ( ( pVideo->pCurrDisplay->buffer == pVideo->pDecodedPict->buffer ) && ( pVideo->currPictCount >= 4 ) && !pVideo->fieldMode )
pVideo->NextInstr.Ovw = 1;/* overwrite mode */
else
pVideo->NextInstr.Ovw = 0;/* not overwite mode */
}
//----------------------------------------------------------------------------
// Store reconstructed,forward and backward frame pointers */
//----------------------------------------------------------------------------
static void NEARAPI VideoStoreRFBBuf (WORD rfp, WORD ffp, WORD bfp )
{
BoardWriteVideo ( RFP, (BYTE)((rfp >> 8 )));
/* Address where to decode the next frame */
BoardWriteVideo ( RFP + 1, (BYTE)((rfp & 0xFF )));
pVideo->pDecodedPict->buffer = rfp;
BoardWriteVideo ( FFP,(BYTE)(( ffp >> 8 )));
/* Used by P picture */
BoardWriteVideo ( FFP + 1, (BYTE)((ffp & 0xFF )));
BoardWriteVideo ( BFP, (BYTE)((bfp >> 8 )));
/* Used by P picture in case of dual prime */
BoardWriteVideo ( BFP + 1, (BYTE)(bfp&0xFF));
}
//----------------------------------------------------------------------------
// Routine called on each VSYNC occurence
//----------------------------------------------------------------------------
static void NEARAPI VideoVsyncRout(void)
{
WORD i;
pVideo->VsyncInterrupt = TRUE;
if ( pVideo->VideoState == StateStartup )
{
if ((VideoGetBBL()) > 2)
{
pVideo->NextInstr.Exe = 1;
pVideo->NextInstr.Seq = 1;
VideoStoreINS(); // Stores Instruction content
pVideo->VideoState = StateWaitForDTS;
pVideo->ActiveState = StateWaitForDTS;
}
return;
}
if ( pVideo->VideoState == StatePause )
return;
if ( ( !pVideo->needDataInBuff ) && ( pVideo->vbvReached == 1 ) )
{
pVideo->VsyncNumber++;
if ( pVideo->VsyncNumber > 4 * ( pVideo->decSlowDown + 1 ) )
{
VideoPipeReset ();
// reset_3500();
pVideo->VsyncNumber = 0;
}
BoardWriteVideo ( DCF, 0 );
BoardWriteVideo ( DCF + 1, (BYTE)(pVideo->currDCF ));
/***** bit buffer level is high enough to continue normal decoding and display ****/
/***** count of the number of time the current picture must be displayed ****/
if ( pVideo->pictDispIndex != pVideo->pCurrDisplay->nb_display_field )
pVideo->pictDispIndex++;
if ( pVideo->pictDispIndex >= pVideo->pCurrDisplay->nb_display_field - 1 )
{
// this is the time where the next INS should be stored
// into the chip
// We verify if the VSYNC phase (cur_field) is the same
// than the first field
// of the next picture to be displayed: if this is VSYNC #
// n, the next
// decoding will start on VSYNC # n+1 (opposite phase)
// while the next frame
// display will start on VSYNC # n+2 (same phase)
/************* Youss R/2P buffer saving ***************************/
// If First Vsync after vbv is reached is of incorrect polarity,
// Program internal field inversion AND force first field to current
// field
// FistVsyncAfterVbv is a 3 state variable
// before vbv is reached FistVsyncAfterVbv = NOT_YET_VBV
// between vbv and following vsync FistVsyncAfterVbv = NOT_YET_VST
// after vsync following vbv FistVsyncAfterVbv = PAST_VBV_AND_VST
if (pVideo->FistVsyncAfterVbv == NOT_YET_VST)
{
if ( pVideo->pNextDisplay->first_field != pVideo->currField )
{
pVideo->currField = pVideo->pNextDisplay->first_field;
BoardWriteVideo(VID_LSRh, 2);// field invertion mechanism.
pVideo->InvertedField = TRUE;
}
pVideo->FistVsyncAfterVbv = PAST_VBV_AND_VST;
}
if ( pVideo->pNextDisplay->first_field != pVideo->currField )
{ // this is the opposite phase
VideoWaitDec (); // put decoder in wait mode
pVideo->pictDispIndex--; // we must wait one field for
// the good phase
}
else
{ // this is the good phase for
// storage
// store the next instruction that will be taken into
// account on the next BOT VSYNC
VideoStoreINS ();
if ( pVideo->VideoState == StateStep ) /* store only one
* instrcution in step
* mode */
pVideo->VideoState = StatePause;
}
}
// the current frame pointer has not been displayed enough
// times
// to start the decoding of the next frame
else // pVideo->pictDispIndex <
{ // pVideo->pCurrDisplay->nb_display_fi
// eld - 1
VideoWaitDec (); // put decoder in Wait mode
}
/* pan & scan vector has to be updated on each new VSYNC */
VideoSetPSV (); // store PSV for next field and
// LSO for current one
} // end of if(!empty)
else
/*** bit buffer level was not high enough to continue normal decoding *****/
/*** decoder has been stopped during PSD interrupt. It will be re-enabled */
/*** on the good VSYNC if the bit buffer level is high enough. ****/
/*** Polarity of the VSYNC on which the decoder was stopped is into empty */
if ( pVideo->needDataInBuff == (WORD)(pVideo->currField))
{
/* This is the good VSYNC phase to restart decoding */
/* verification of the bit buffer level before restarting */
/* the decoder has been stopped for at least two VSYNC */
i = VideoGetBBL();
if ( i >= pVideo->vbvDelay )
{
// BBL is high enough to restart
// "enable decoding" bit
VideoEnableDecoding(ON);
pVideo->needDataInBuff = 0;
}
}
}
//----------------------------------------------------------------------------
//
//----------------------------------------------------------------------------
static void NEARAPI VideoChooseField(void)
{
BYTE dcf0, dcf1, bfs=0;
// to avoid flicker with slow motion or step by step, the top field is displayed
// half of the time of the picture, and then the bottom field is displayed
if ( ( pVideo->decSlowDown ) || ( pVideo->VideoState == StatePause )||(pVideo->perFrame == TRUE ))
{
bfs = BoardReadVideo(CFG_BFS)&0x3F;// To check if B frame optimization is on
dcf0 = BoardReadVideo ( DCF );
dcf1 = BoardReadVideo ( DCF + 1 );
if ( pVideo->HalfRes == FALSE ) /* full resolution
* picture = 2 fields */
{
dcf1 |= 0x80;
if ( ( ( ( ( pVideo->pictDispIndex + pVideo->decSlowDown ) > 0x7fff ) || ( pVideo->pictDispIndex == 1 ) ) && ( pVideo->VideoState != StatePause ) )
|| ( ( pVideo->VideoState == StatePause ) && ( !pVideo->displaySecondField ) ) )
{
/* display first field in two cases */
/* - first half of the pVideo->decSlowDownrisation time */
/* - first step() pVideo->currCommand */
if ( pVideo->pCurrDisplay->first_field == TOP )
{ /* first field = TOP field */
if(!bfs)
BoardWriteVideo ( DCF, 0x4 );//FRZ set for STi3520A
else
BoardWriteVideo ( DCF, 0x15 );//FRZ set for STi3520A
BoardWriteVideo ( DCF + 1, dcf1);
}
else
{ /* first field = BOT field */
if(!bfs)
BoardWriteVideo ( DCF, 0x5 );
else
BoardWriteVideo ( DCF, 0x14 );//FRZ set for STi3520A
BoardWriteVideo ( DCF + 1, dcf1);
}
}
else
{
/* display second field in two cases */
/* - second half of the pVideo->decSlowDownrisation time */
/* - second step() pVideo->currCommand */
if ( pVideo->pCurrDisplay->first_field == TOP )
{
if(!bfs)
BoardWriteVideo ( DCF, 0x5);
else
BoardWriteVideo ( DCF, 0x15 );//FRZ set for STi3520A
BoardWriteVideo ( DCF + 1, dcf1);
}
else
{
if(!bfs)
BoardWriteVideo ( DCF, 0x4);
else
BoardWriteVideo ( DCF, 0x14 );//FRZ set for STi3520A
BoardWriteVideo ( DCF + 1, dcf1);
}
}
}
}
}
static BOOL NEARAPI IsChipSTi3520(void)
{
//---- Write STi3520 DCF register to 0
BoardWriteVideo(0x78, 0);
BoardWriteVideo(0x79, 0);
//---- Read back DCF MSByte
if (BoardReadVideo(0x78) != 0)
return FALSE; // we have red STi3520A VID_REV register
else
return TRUE; // we have red STi3520 DCF register
}
//----------------------------------------------------------------------------
//
//----------------------------------------------------------------------------
WORD FARAPI SendAudioIfPossible(LPBYTE pBuffer, WORD Size)
{
if ( AudioIsEnoughPlace(Size)) {
BoardSendAudio(pBuffer, Size);
return Size;
}
return 0;
}
//----------------------------------------------------------------------------
//
//----------------------------------------------------------------------------
WORD FARAPI SendAudioToVideoIfPossible(LPBYTE Buffer, WORD Size)
{
if ( AudioIsEnoughPlace(Size)) {
BoardSendVideo((WORD *)Buffer, Size);// Here in case of system stream
// We send audio through Video Strabe
return Size;
}
return 0;
}
//----------------------------------------------------------------------------
//
//----------------------------------------------------------------------------
static void NEARAPI VideoSetABStart(WORD abg)
{
BoardWriteVideo ( AUD_ABG, (BYTE)(abg >> 8));// Initiate Write to Command
BoardWriteVideo ( AUD_ABG + 1,(BYTE)(abg & 0xFF));
}
//----------------------------------------------------------------------------
//
//----------------------------------------------------------------------------
WORD FARAPI VideoGetABL(void)
{
WORD i;
HostDisableIT();
i = (WORD)( BoardReadVideo ( AUD_ABL ) & 0x3F ) << 8;
i = i | (WORD)( BoardReadVideo ( AUD_ABL + 1 ) );
HostEnableIT();
return ( i );
}
//----------------------------------------------------------------------------
//
//----------------------------------------------------------------------------
static void NEARAPI VideoSetABStop(WORD abs)
{
BoardWriteVideo ( AUD_ABS, (BYTE)(abs >> 8 ));// Initiate Write to Command
BoardWriteVideo ( AUD_ABS + 1,(BYTE)(abs & 0xFF));
}
//----------------------------------------------------------------------------
//
//----------------------------------------------------------------------------
static void NEARAPI VideoSetABThresh(WORD abt)
{
BoardWriteVideo ( AUD_ABT, (BYTE)(abt >> 8));// Initiate Write to Command
BoardWriteVideo ( AUD_ABT + 1,(BYTE)(abt & 0xFF));
}
//----------------------------------------------------------------------------
//
//----------------------------------------------------------------------------
WORD FARAPI SendVideoIfPossible(LPBYTE Buffer, WORD Size)
{
if (VideoIsEnoughPlace(Size)) {
BoardSendVideo((WORD *)Buffer, Size);
return Size;
}
return 0;
}
//----------------------------------------------------------------------------
//
//----------------------------------------------------------------------------
static void NEARAPI VideoSetBBStart(WORD bbg)
{
pVideo = pVideo;
BoardWriteVideo ( VID_VBG, (BYTE)(bbg >> 8));// Initiate Write to Command
BoardWriteVideo ( VID_VBG + 1,(BYTE)(bbg & 0xFF));
}
//----------------------------------------------------------------------------
//
//----------------------------------------------------------------------------
static WORD NEARAPI VideoGetBBL(void)
{
WORD i;
HostDisableIT();
i = (WORD)( BoardReadVideo ( BBL ) & 0x3F ) << 8;
i = i | (WORD)( BoardReadVideo ( BBL + 1 ) );
HostEnableIT();
return ( i );
}
//----------------------------------------------------------------------------
//
//----------------------------------------------------------------------------
static void NEARAPI VideoSetBBStop(WORD bbs)
{
BoardWriteVideo ( BBS, (BYTE)(bbs >> 8));// Initiate Write to Command
BoardWriteVideo ( BBS + 1,(BYTE)(bbs & 0xFF));
}
//----------------------------------------------------------------------------
//
//----------------------------------------------------------------------------
static void NEARAPI VideoSetBBThresh(WORD bbt)
{
BoardWriteVideo ( BBT, (BYTE)(bbt >> 8));// Initiate Write to Command
BoardWriteVideo ( BBT + 1,(BYTE)(bbt & 0xFF));
}
//----------------------------------------------------------------------------
//
//----------------------------------------------------------------------------
static WORD NEARAPI VideoBlockMove(DWORD SrcAddress, DWORD DestAddress, WORD Size)
{
WORD counter;
// set block move Size
BoardWriteVideo ( BMS , (BYTE)((Size >> 8) & 0xFF));
BoardWriteVideo ( BMS , (BYTE)(Size & 0xFF));
VideoSetMWP(DestAddress);
VideoSetMRP(SrcAddress); // Launches Block Move
counter = 0;
while ( ! VideoBlockMoveIdle() )
{
counter ++;
if(counter == 0xFFFF)
return ( BAD_MEM_V );
}
// wait for the end of the block move
return ( NO_ERROR );
}
//----------------------------------------------------------------------------
//
//----------------------------------------------------------------------------
static void NEARAPI VideoStartBlockMove(DWORD SrcAddress, DWORD DestAddress, DWORD Size)
{
SrcAddress = SrcAddress;
DestAddress = DestAddress;
Size = Size;
}
//----------------------------------------------------------------------------
//
//----------------------------------------------------------------------------
static void NEARAPI VideoCommandSkip(WORD Nbpicture)
{
if(Nbpicture > 2)
{
pVideo->errCode = ERR_SKIP;
}
else
{
}
}
//----------------------------------------------------------------------------
//
//----------------------------------------------------------------------------
static void NEARAPI VideoSetSRC(WORD SrceSize, WORD DestSize)
{
DWORD lsr;
lsr = ( 256 * ( long ) ( SrceSize - 4 ) ) / (DestSize - 1);
BoardWriteVideo ( LSO, 0 ); // programmation of the SRC
BoardWriteVideo ( LSR, (BYTE)lsr );
if(lsr > 255 )
{
BoardWriteVideo ( VID_LSRh, 1);
}
BoardWriteVideo ( CSO, 0 );
VideoSRCOn ();
}
//----------------------------------------------------------------------------
// Load Quantization Matrix
//----------------------------------------------------------------------------
static void NEARAPI VideoLoadQuantTables(BOOL Intra,BYTE * Table )
{
WORD i; // loop counter
// Select Intra / Non Intra Table
if(Intra)
BoardWriteVideo(VID_HDS,QMI);
else
BoardWriteVideo(VID_HDS,(0&~QMI));
// Load Table
for (i = 0 ; i < QUANT_TAB_SIZE ; i++)
BoardWriteVideo(VID_QMW,Table[i]);
// Lock Table Again
BoardWriteVideo(VID_HDS,0);
}
//----------------------------------------------------------------------------
// Computes Instruction and stores in Ins1 Ins2 Cmd vars
//----------------------------------------------------------------------------
static void NEARAPI VideoComputeInst(void)
{
INSTRUCTION Ins = pVideo->NextInstr;// Local var.
pVideo->Ppr1 = (Ins.Pct<< 4)|(Ins.Dcp<< 2)|(Ins.Pst );
pVideo->Ppr2 = (Ins.Tff<< 5)|(Ins.Frm<<4)|(Ins.Cmv<< 3)|(Ins.Qst<< 2)|
(Ins.Ivf<< 1)|(Ins.Azz );
pVideo->Tis = (Ins.Mp2<< 6)|(Ins.Skip<< 4)|(Ins.Ovw<< 3)|(Ins.Rpt<< 1)|
(Ins.Exe );
pVideo->Pfh = (Ins.Bfh<< 4)|(Ins.Ffh );
pVideo->Pfv = (Ins.Bfv<< 4)|(Ins.Ffv );
}
//----------------------------------------------------------------------------
// put the decoder into WAIT mode
//----------------------------------------------------------------------------
/* This routine actually clears all bits of INS1/TIS registers
This is not a problem since the whole registers HAVE to
be rewritten when storing a new instruction. */
static void NEARAPI VideoWaitDec (void)
{
BoardWriteVideo ( VID_TIS, 0 );
VideoChooseField();// If Step by step decoding, set freeze bit
}
//----------------------------------------------------------------------------
// Routine storing pVideo->nextInstr1 and 2 into the instruction registers
//----------------------------------------------------------------------------
static void NEARAPI VideoStoreINS (void)
{
VideoComputeInst() ;
BoardWriteVideo ( VID_TIS , pVideo->Tis );
BoardWriteVideo ( VID_PPR1, pVideo->Ppr1 );
BoardWriteVideo ( VID_PPR2, pVideo->Ppr2 );
BoardWriteVideo ( VID_PFV , pVideo->Pfv );
BoardWriteVideo ( VID_PFH , pVideo->Pfh );
}
//----------------------------------------------------------------------------
// Routine reading the number of bytes loaded in the CD_FIFO
//----------------------------------------------------------------------------
static DWORD NEARAPI ReadCDCount (void)
{
DWORD cd;
HostDisableIT();
cd = ((DWORD)(BoardReadVideo(CDcount)&0xFF))<<16;
cd |= ((DWORD)(BoardReadVideo(CDcount)&0xFF))<<8;
cd |= (DWORD)(BoardReadVideo(CDcount)&0xFF);
HostEnableIT( );
return ( cd );
}
//----------------------------------------------------------------------------
// Routine reading the number of bytes extracted by the SCD
//----------------------------------------------------------------------------
static DWORD NEARAPI ReadSCDCount (void)
{
DWORD Scd;
HostDisableIT ( );
Scd = ((DWORD)(BoardReadVideo(SCDcount)&0xFF))<<16;
Scd |= ((DWORD)(BoardReadVideo(SCDcount)&0xFF))<<8;
Scd |= (DWORD)(BoardReadVideo(SCDcount)&0xFF);
HostEnableIT ( );
return ( Scd );
}
//----------------------------------------------------------------------------
// DRAM I/O
//----------------------------------------------------------------------------
static void NEARAPI VideoSetMWP(DWORD mwp)
{
BYTE m0, m1, m2;
m0 = (BYTE)( (mwp >> 14) & 0xFF );
m1 = (BYTE)( (mwp >> 6) & 0xFF );
m2 = (BYTE)( (mwp << 2) & 0xFF );
BoardWriteVideo(MWP , m0);
BoardWriteVideo(MWP , m1);
BoardWriteVideo(MWP , m2);
}
//----------------------------------------------------------------------------
//
//----------------------------------------------------------------------------
static void NEARAPI VideoSetMRP(DWORD mrp)
{
BYTE m0, m1, m2;
m0 = (BYTE)( (mrp >> 14) & 0xFF );
m1 = (BYTE)( (mrp >> 6) & 0xFF );
m2 = (BYTE)( (mrp << 2) & 0xFF );
BoardWriteVideo(MRP , m0);
BoardWriteVideo(MRP , m1);
BoardWriteVideo(MRP , m2);
}
//----------------------------------------------------------------------------
//
//----------------------------------------------------------------------------
static BOOL NEARAPI VideoMemWriteFifoEmpty( void )
{
return ( (BoardReadVideo ( STA ) & 0x4) );
}
//----------------------------------------------------------------------------
//
//----------------------------------------------------------------------------
static BOOL NEARAPI VideoMemReadFifoFull( void )
{
return ( (BoardReadVideo ( STA ) & 0x8) );
}
//----------------------------------------------------------------------------
//
//----------------------------------------------------------------------------
static BOOL NEARAPI VideoHeaderFifoEmpty( void )
{
BoardReadVideo ( STA );
return ( (BoardReadVideo ( STA + 1 ) & 0x4) );
}
//----------------------------------------------------------------------------
//
//----------------------------------------------------------------------------
static BOOL NEARAPI VideoBlockMoveIdle( void )
{
return ( (BoardReadVideo ( STA ) & 0x20) );
}
//----------------------------------------------------------------------------
//
//----------------------------------------------------------------------------
static void NEARAPI VideoEnableDecoding(BOOL OnOff)
{
if(OnOff)
pVideo->Ctl |= EDC;
else
pVideo->Ctl &= ~EDC;
BoardWriteVideo(CTL , (BYTE)(pVideo->Ctl & 0xFF));
}
//----------------------------------------------------------------------------
//
//----------------------------------------------------------------------------
static void NEARAPI VideoEnableErrConc(BOOL OnOff)
{
if(OnOff)
pVideo->Ctl = (pVideo->Ctl |EPR|ERS|ERU)&~DEC;
else
pVideo->Ctl = (pVideo->Ctl&~EPR&~ERS&~ERU)|DEC;
BoardWriteVideo(CTL , (BYTE)(pVideo->Ctl & 0xFF ));
}
//----------------------------------------------------------------------------
// pipeline RESET
//----------------------------------------------------------------------------
static void NEARAPI VideoPipeReset (void)
{
pVideo->Ctl |= PRS;
BoardWriteVideo(CTL , (BYTE)(pVideo->Ctl));
Delay(1000);
pVideo->Ctl &= ~PRS;
BoardWriteVideo(CTL , (BYTE)(pVideo->Ctl));
}
//----------------------------------------------------------------------------
//
//----------------------------------------------------------------------------
static void NEARAPI VideoSoftReset (void)
{
pVideo->Ctl |= SRS;
BoardWriteVideo(CTL , (BYTE)(pVideo->Ctl));
Delay(1000);
pVideo->Ctl &= ~SRS;
BoardWriteVideo(CTL , (BYTE)(pVideo->Ctl));
}
//----------------------------------------------------------------------------
//
//----------------------------------------------------------------------------
static void NEARAPI VideoEnableInterfaces (BOOL OnOff )
{
if(OnOff)
pVideo->Ccf = pVideo->Ccf |EVI|EDI|ECK|EC2|EC3;
else
pVideo->Ccf = pVideo->Ccf&~EVI&~EDI&~ECK&~EC2&~EC3;
BoardWriteVideo(CFG_CCF, (BYTE)(pVideo->Ccf));
}
//----------------------------------------------------------------------------
//
//----------------------------------------------------------------------------
static void NEARAPI VideoPreventOvf(BOOL OnOff )
{
if(OnOff)
pVideo->Ccf = pVideo->Ccf |PBO;
else
pVideo->Ccf = pVideo->Ccf&~PBO;
BoardWriteVideo(CFG_CCF,(BYTE)(pVideo->Ccf));
}
//----------------------------------------------------------------------------
//
//----------------------------------------------------------------------------
static void NEARAPI VideoSetFullRes(void)
{
pVideo->HalfRes = FALSE;
pVideo->currDCF = pVideo->currDCF | pVideo->fullVerFilter;
BoardWriteVideo ( DCF, 0 );
BoardWriteVideo ( DCF + 1, (BYTE)(pVideo->currDCF));
}
//----------------------------------------------------------------------------
//
//----------------------------------------------------------------------------
static void NEARAPI VideoSetHalfRes(void)
{
pVideo->HalfRes = TRUE;
// No PAL optimization in Half Res
BoardWriteVideo(CFG_BFS , 0);
pVideo->currDCF = pVideo->currDCF | pVideo->halfVerFilter;
BoardWriteVideo ( DCF, 0 );
BoardWriteVideo ( DCF + 1, (BYTE)(pVideo->currDCF));
}
//----------------------------------------------------------------------------
//
//----------------------------------------------------------------------------
static void NEARAPI VideoSelect8M(BOOL OnOff)
{
if(OnOff)
pVideo->Ccf = pVideo->Ccf |M32;
else
pVideo->Ccf = pVideo->Ccf&~M32;
BoardWriteVideo(CFG_CCF, (BYTE)(pVideo->Ccf));
}
//----------------------------------------------------------------------------
// GCF1 register Routines
//----------------------------------------------------------------------------
static void NEARAPI VideoSetDramRefresh(WORD Refresh)
{
pVideo->Gcf = pVideo->Gcf |(Refresh & RFI);
BoardWriteVideo(CFG_MCF, (BYTE)(pVideo->Gcf));
}
//----------------------------------------------------------------------------
//
//----------------------------------------------------------------------------
static void NEARAPI VideoSelect20M(BOOL OnOff)
{
if(OnOff)
pVideo->Gcf = pVideo->Gcf | M20;
else
pVideo->Gcf = pVideo->Gcf &~M20;
BoardWriteVideo(CFG_MCF, (BYTE)(pVideo->Gcf));
}
//----------------------------------------------------------------------------
//
//----------------------------------------------------------------------------
static void NEARAPI VideoSetDFA(WORD dfa)
{
BoardWriteVideo(VID_DFA , (BYTE)(dfa>>8));
BoardWriteVideo(VID_DFA , (BYTE)(dfa));
}
//----------------------------------------------------------------------------
//
//----------------------------------------------------------------------------
static void NEARAPI VideoEnableDisplay(void)
{
pVideo->currDCF = pVideo->currDCF |0x20;
BoardWriteVideo ( DCF, 0 );
BoardWriteVideo ( DCF + 1, (BYTE)(pVideo->currDCF));
}
//----------------------------------------------------------------------------
//
//----------------------------------------------------------------------------
static void NEARAPI VideoDisableDisplay(void)
{
pVideo->currDCF = pVideo->currDCF &(~0x20);
BoardWriteVideo ( DCF, 0 );
BoardWriteVideo ( DCF + 1, (BYTE)(pVideo->currDCF));
}
//----------------------------------------------------------------------------
//
//----------------------------------------------------------------------------
void FARAPI VideoInitPesParser(STREAMTYPE StreamType )
{
switch(StreamType)
{
case SYSTEM_STREAM:
case VIDEO_PACKET:
case AUDIO_PACKET:
case VIDEO_PES:
case AUDIO_PES:
BoardWriteVideo( PES_VID, 0x30);
BoardWriteVideo( PES_AUD, 0x0);
break;
case DUAL_PES:
BoardWriteVideo( PES_VID, 0xB0 );
BoardWriteVideo( PES_AUD, 0X0 );
break;
case DUAL_ES:
case VIDEO_STREAM:
case AUDIO_STREAM:
BoardWriteVideo( PES_VID, 0 );
BoardWriteVideo( PES_AUD, 0 );
break;
}
}
//----------------------------------------------------------------------------
// reads PTS value from STi3520A
//----------------------------------------------------------------------------
DWORD FARAPI BoardReadVideoPTS(void)
{
DWORD pts;
pts = ( (DWORD)BoardReadVideo(PES_TS4 ) & 0xFFL ) << 24;
pts = pts | ( (DWORD)( BoardReadVideo(PES_TS3 ) & 0xFFL ) << 16);
pts = pts | ( (DWORD)( BoardReadVideo(PES_TS2 ) & 0xFFL ) << 8);
pts = pts | ( (DWORD) BoardReadVideo(PES_TS1 ) & 0xFFL );
return pts;
}
//----------------------------------------------------------------------------
// Returns TRUE if current PTS is Valid
//----------------------------------------------------------------------------
BOOL FARAPI VideoIsValidPTS(void)
{
if( BoardReadVideo(PES_TS5 ) & 0x2 ) // read TSA bit
return TRUE;
}
WORD FARAPI VideoTestReg(void)
{
BoardWriteVideo(MWP , 0x05);
BoardWriteVideo(MWP , 0x55);
BoardWriteVideo(MWP , 0xAA);
if ((BoardReadVideo(MWP) & 0x1F) != 0x05)
goto Error;
if (BoardReadVideo(MWP) != 0x55)
goto Error;
if ((BoardReadVideo(MWP) & 0xFC) != 0xA8)
goto Error;
return NO_ERROR;
Error :
DPF((Trace,"VideoTestReg failed !!"));
SetErrorCode(ERR_VIDEO_REG_TEST_FAILED);
return BAD_REG_V;
}
//----------------------------------------------------------------------------
//
//----------------------------------------------------------------------------
WORD FARAPI VideoTestMemPat(WORD pattern, WORD pattern1)
{
// Configure memory refresh = 36
#define MAXMEM 0x7FF
WORD i, j;
WORD counter;
VideoSetMWP(0L);
counter = 0;
for (i = 0; i < MAXMEM; i++) {
for (j = 0; j < 16; j++)
{
while (!(BoardReadVideo ( STA ) & 0x4)) {
counter ++;
if (counter == 0xFF0)
goto Error;
DPF((Trace,"Waiting Write Fifo Empty"));
}
BoardWriteVideo(MWF, 0);
}
}
VideoSetMWP(0L);
counter = 0;
for (i = 0; i < MAXMEM; i++) {
for(j = 0; j < 8; j++ )
{
while (!(BoardReadVideo ( STA ) & 0x4)) {
counter ++;
if (counter == 0xFF0)
goto Error;
DPF((Trace,"Waiting Write Fifo Empty"));
}
BoardWriteVideo(MWF, (BYTE)pattern);
}
counter = 0;
for(j = 0; j < 8; j++ ){
while (!VideoMemWriteFifoEmpty()) { // ACCESS TO MEM FIFO IS SLOWER !!!
DPF((Trace,"Waiting Write Fifo Empty"));
counter ++;
if (counter == 0xFF0)
goto Error;
}
BoardWriteVideo(MWF, (BYTE)pattern1);
}
}
VideoSetMRP(0L);
counter = 0;
// test Read Fifo Full
for(i = 0; i < MAXMEM; i++) {
for (j = 0; j < 8; j++) {
while (!VideoMemReadFifoFull()) {
DPF((Trace,"Waiting Read Fifo Full"));
counter ++;
if (counter == 0xFF0)
goto Error;
}
counter = BoardReadVideo(MRF);
if (counter !=pattern) {
DPF((Trace,"Counter = %x, pattern = %x, j = %x", counter, pattern, j));
goto Error;
}
}
counter = 0;
for (j = 0; j < 8; j++) {
counter = BoardReadVideo(MRF);
while (!VideoMemReadFifoFull()) {
DPF((Trace,"Waiting Read Fifo Full"));
counter ++;
if (counter == 0xFF0)
goto Error;
}
if ((WORD)counter != pattern1) {
DPF((Trace,"Counter = %x, pattern = %x, j = %x", counter, pattern, j));
goto Error;
}
}
}
return NO_ERROR;
Error :
DPF((Trace,"VideoTestMemPat failed !!"));
SetErrorCode(ERR_TEST_MEMORY_FAILED);
return BAD_MEM_V;
}
//----------------------------------------------------------------------------
//
//----------------------------------------------------------------------------
WORD FARAPI VideoTestMem(void)
{
// if (VideoTestMemPat(0x55, 0xAA) == NO_ERROR)
// return VideoTestMemPat(0xAA, 0x55);
// else
// return BAD_MEM_V;
return NO_ERROR;
}
//----------------------------------------------------------------------------
//
//----------------------------------------------------------------------------
static void NEARAPI VideoInitVar(STREAMTYPE StreamType)
{
Sequence =1;
pVideo->currDCF = 0x40; /* one clock delay + force black
* background */
pVideo->LastCdCount = 0;
pVideo->fullVerFilter = 0x0;
pVideo->halfVerFilter = 0x4;
pVideo->Xdo = pCard->OriginX; /* pre initialise XDO */
pVideo->Ydo = pCard->OriginY; /* pre initialise YDO */
pVideo->Xd1 = 0xFFFF; /* pre initialise end of video
* window */
pVideo->Yd1 = 0xFFFF; /* pre initialisa end of video
* window */
pVideo->fastForward = 0; /* accelerate if set */
pVideo->decSlowDown = 0;
pVideo->perFrame = FALSE;
pVideo->LastPipeReset = 2;
pVideo->errCode = 0;
pVideo->StreamInfo.countGOP = 0;
pVideo->StreamInfo.frameRate = 5; // just to avoid erroneous warning
pVideo->useSRC = 0x0; // disable SRC
pVideo->seqDispExt = 0;
pVideo->skipMode = 0;
pVideo->currCommand = 0;
pVideo->needDataInBuff = 0;
pVideo->currPictCount = 0; /* first picture of the bit stream */
pVideo->defaultTbl = 0; /* To know if default tables are already into the chip */
pVideo->GOPindex = 0;
// initialisation of the picture structures
pVideo->pictArray[0].tempRef = 1025;
pVideo->pictArray[1].tempRef = 1023;
pVideo->pictArray[2].tempRef = 1025;
pVideo->pictArray[3].tempRef = 1025;
pVideo->currTempRef = 1022; /* display pVideo->decSlowDownral reference */
pVideo->pNextDisplay = &pVideo->pictArray[3];
pVideo->pCurrDisplay = &pVideo->pictArray[3]; // this is only for correct
// start up
pVideo->pictArray[0].nb_display_field = 2;
// 2 field display time for MPEG1
pVideo->pictArray[1].nb_display_field = 2;
pVideo->pictArray[2].nb_display_field = 2;
pVideo->pictArray[3].nb_display_field = 2;
pVideo->pictArray[0].first_field = TOP; // default for MPEG1 bit streams
pVideo->pictArray[1].first_field = TOP; // top field first
pVideo->pictArray[2].first_field = TOP;
pVideo->pictArray[3].first_field = TOP;
pVideo->fieldMode = 0; // indicates frame picture by
// default
pVideo->frameStoreAttr = FORWARD_PRED;
pVideo->vbvReached = 0;
pVideo->notInitDone = 1; // timing generator,picture size
// initialised only once
pVideo->intMask = 0x0;
pVideo->Gcf = 0; // GCF set to 0 by default
pVideo->Ctl = A35; // CTL set to 0 by default
pVideo->InvertedField = FALSE;
pVideo->FistVsyncAfterVbv = NOT_YET_VBV;
pVideo->Ccf = 0; // GCF set to 0 by default
pVideo->NextInstr.Tff = 1 ;
pVideo->NextInstr.Seq = 1 ;
pVideo->NextInstr.Exe = 1 ;
}
static void NEARAPI VideoReset35XX(STREAMTYPE StreamType)
{
WORD Abg, Abs, Vbg, Vbs;
pVideo->AudioBufferSize = 0xFF;
switch(StreamType)
{
case SYSTEM_STREAM:
case AUDIO_PACKET:
case VIDEO_PACKET:
pVideo->VideoBufferSize = BUF_FULL/3 - pVideo->AudioBufferSize-1;
break;
default:
pVideo->VideoBufferSize = BUF_FULL - pVideo->AudioBufferSize-1;
break;
}
Vbg = 0;
Vbs = Vbg + pVideo->VideoBufferSize;
Abg = Vbs+1;
Abs = Abg + pVideo->AudioBufferSize;
pVideo->StreamInfo.modeMPEG2 = 0;
pVideo->NextInstr = pVideo->ZeroInstr;// Clear Next Instruction
VideoInitPLL();
VideoWaitDec(); // put decoder in Wait mode
VideoSetABStart( Abg);// Set Bit Buffer parameters before Soft Reset
VideoSetABStop(Abs);
VideoSetABThresh(pVideo->AudioBufferSize);
VideoSetBBStart(Vbg);// Set Bit Buffer parameters before Soft Reset
VideoSetBBStop(Vbs);
VideoSetBBThresh(pVideo->VideoBufferSize);
VideoEnableInterfaces(ON);
VideoEnableErrConc(ON);
VideoSoftReset();
VideoEnableDecoding(ON );
VideoSetDramRefresh(36); // Set DRAM refresh to 36 default DRAM ref period
VideoDisableDisplay();
VideoMaskInt();
BoardReadVideo(ITS); /* to clear ITS */
BoardReadVideo(ITS +1);
BoardReadVideo(ITS1);
}
static void NEARAPI VideoSeek(STREAMTYPE StreamType)
{
WORD Abg, Abs, Vbg, Vbs;
pVideo->AudioBufferSize = 0xFF;
switch(StreamType)
{
case SYSTEM_STREAM:
case AUDIO_PACKET:
case VIDEO_PACKET:
pVideo->VideoBufferSize = BUF_FULL/3 - pVideo->AudioBufferSize-1;
break;
default:
pVideo->VideoBufferSize = BUF_FULL - pVideo->AudioBufferSize-1;
break;
}
Vbg = 0;
Vbs = Vbg + pVideo->VideoBufferSize;
Abg = Vbs+1;
Abs = Abg + pVideo->AudioBufferSize;
pVideo->StreamInfo.modeMPEG2 = 0;
pVideo->NextInstr = pVideo->ZeroInstr;// Clear Next Instruction
// VideoInitPLL();
VideoWaitDec(); // put decoder in Wait mode
// VideoSetABStart( Abg);// Set Bit Buffer parameters before Soft Reset
// VideoSetABStop(Abs);
// VideoSetABThresh(pVideo->AudioBufferSize);
// VideoSetBBStart(Vbg);// Set Bit Buffer parameters before Soft Reset
// VideoSetBBStop(Vbs);
// VideoSetBBThresh(pVideo->VideoBufferSize);
VideoEnableInterfaces(ON);
VideoEnableErrConc(ON);
VideoSoftReset();
VideoEnableDecoding(ON );
VideoSetDramRefresh(36); // Set DRAM refresh to 36 default DRAM ref period
// VideoDisableDisplay();
VideoMaskInt();
BoardReadVideo(ITS); /* to clear ITS */
BoardReadVideo(ITS +1);
BoardReadVideo(ITS1);
}
//----------------------------------------------------------------------------
// PLL initialization
//----------------------------------------------------------------------------
static void NEARAPI VideoInitPLL(void)
{
BoardWriteVideo(CKG_PLL, 0xD9);
BoardWriteVideo(CKG_VID, 0x22);
BoardWriteVideo(CKG_VID, 0x08);
BoardWriteVideo(CKG_VID, 0x5f);
BoardWriteVideo(CKG_VID, 0x0f);
BoardWriteVideo(CKG_AUD, 0x2b);
BoardWriteVideo(CKG_AUD, 0x02);
BoardWriteVideo(CKG_AUD, 0x5f);
BoardWriteVideo(CKG_AUD, 0x5f);
BoardWriteVideo(CKG_CFG, 0x83);
}
#define SIZE_OF_PICT 540
//----------------------------------------------------------------------------
// Enable OSD
//----------------------------------------------------------------------------
static void NEARAPI VideoOsdOn(void)
{
pVideo->currDCF = pVideo->currDCF | 0x10;
HostDisableIT();
BoardWriteVideo(DCF, 0);
BoardWriteVideo(DCF + 1, (BYTE)pVideo->currDCF);
HostEnableIT();
}
//----------------------------------------------------------------------------
// Disable OSD
//----------------------------------------------------------------------------
static void NEARAPI VideoOsdOff (void)
{
pVideo->currDCF = pVideo->currDCF & 0xEF;
HostDisableIT();
BoardWriteVideo(DCF, 0);
BoardWriteVideo(DCF + 1,(BYTE) pVideo->currDCF);
HostEnableIT();
}
//----------------------------------------------------------------------------
// initialisation of the OSD pointers
//----------------------------------------------------------------------------
static void NEARAPI VideoInitOEP (DWORD point_oep)
{
BYTE x;
// Bugy code!! generates compiler error
// Needs tp be fixed - JBS
/*
x = (BYTE)(point_oep >> 13);
BoardWriteVideo(VID_OBP,x);
x = (BYTE)(point_oep >> 5);
BoardWriteVideo(VID_OBP, x);
x = (BYTE)(point_oep >> 13);
BoardWriteVideo(VID_OTP, x);
x = (BYTE)(point_oep >> 5);
BoardWriteVideo(VID_OTP, x);
*/
}
//----------------------------------------------------------------------------
// Set video window position and size (top left=X0,Y0) (bottom right=X1,Y1)
//----------------------------------------------------------------------------
void FARAPI VideoSetVideoWindow (WORD a, WORD b, WORD c, WORD d )
{
a=a|1;
pVideo->Xdo = a;
pVideo->Ydo = b;
pVideo->Xd1 = c;
pVideo->Yd1 = d;
VideoInitXY ();
}
//----------------------------------------------------------------------------
// Initialisation of the horizontal & vertical offsets
//----------------------------------------------------------------------------
void FARAPI VideoInitXY(void)
{
WORD yds, xds;
// set vertical stop position
if ( pVideo->StreamInfo.verSize <= 288 ) // half res decoding
yds = pVideo->StreamInfo.verSize + pVideo->Ydo - 129;
/* number of lines + offset - 128 - 1 */
else // full resolution decoding
yds = ( pVideo->StreamInfo.verSize >> 1 ) + pVideo->Ydo - 129;
/* number of lines + offset - 128 - 1 */
if ( yds > pVideo->Yd1 )
yds = pVideo->Yd1;
// set horizontal stop position: we always display 720 pixels
// XDS given by the relation: 2*XDO + 40 + 2*L = 2*XDS + 28
// XDS = XDO + 726 with 720 displayed pixels.
xds = pVideo->Xdo + 726;
if ( xds > 800 ) /* 800 = max number of pels allowed per line */
xds = 800;
if ( xds > pVideo->Xd1 )
xds = pVideo->Xd1; /* not bigger than the video window */
SetXY(xds, yds );
}
//----------------------------------------------------------------------------
// Storage of the horizontal & vertical offsets
//----------------------------------------------------------------------------
void FARAPI SetXY(WORD xds, WORD yds)
{
BoardWriteVideo ( XDO , (BYTE)(pVideo->Xdo >> 8 ));
BoardWriteVideo ( XDO+1 , (BYTE)(pVideo->Xdo & 0xFF ));
BoardWriteVideo ( YDO , (BYTE)(pVideo->Ydo ));
BoardWriteVideo ( XDS , (BYTE)(xds >> 8 ));
BoardWriteVideo ( XDS+1 , (BYTE)(xds & 0xFF ));
BoardWriteVideo ( YDS , (BYTE)yds );
}
//----------------------------------------------------------------------------
// Set next display frame pointer
//----------------------------------------------------------------------------
/*
This routine determines which is the next frame pointer that
must be used for display. It takes care about the fact that
the temporal references may not be consecutive in case of
sikipped pictures...
*/
static void NEARAPI VideoDisplayCtrl(void)
{
WORD comput1, index;
WORD min_temp_ref;
WORD cur_ref;
min_temp_ref = ( pVideo->currTempRef & 0xF000 ) + 1024;
// keep current pVideo->GOPindex
index = 5;
pVideo->currTempRef++; /* increment display temporal ref */
/************** WARNING ************/
// this routine will not work properly if GOP size > 1023
if ( ( pVideo->currTempRef & 0xFFF ) > 1023 ) // 2 msb are used as pVideo->GOPindex
pVideo->currTempRef = pVideo->currTempRef & 0xF000; /* max temp ref is 1023: reset to 0 */
/* search frame store to display */
for (comput1 = 0; comput1 <= 3; comput1++) {
cur_ref = pVideo->pictArray[comput1].tempRef & 0xFFF;
if ( ( ( pVideo->currTempRef & 0xF000 ) == ( pVideo->pictArray[comput1].tempRef & 0xF000 ) )
&& ( pVideo->currTempRef <= pVideo->pictArray[comput1].tempRef )
&& ( min_temp_ref > cur_ref ) ) {
// pVideo->currTempRef and pVideo->pictArray[comput1] refer to the same GOP
// we want to extract the minimum temporal reference
min_temp_ref = cur_ref;
index = comput1;
}
}
if (index == 5) {
/*
There is a group of pictures change: reset pVideo->currTempRef and
increment pVideo->GOPindex
*/
pVideo->currTempRef = ( pVideo->currTempRef & 0xF000 ) + 0x4000;
min_temp_ref = min_temp_ref + 0x4000;
/* search frame store to display */
for (comput1 = 0; comput1 <= 3; comput1++) {
cur_ref = pVideo->pictArray[comput1].tempRef & 0xFFF;
if ( ( ( pVideo->currTempRef & 0xF000 ) == ( pVideo->pictArray[comput1].tempRef & 0xF000 ) )
&& ( pVideo->currTempRef <= pVideo->pictArray[comput1].tempRef )
&& ( min_temp_ref > cur_ref ) ) {
// pVideo->currTempRef and pVideo->pictArray[comput1] refer to the same GOP
// we want to extract the minimum temporal reference
min_temp_ref = cur_ref;
index = comput1;
}
}
}
if (index == 5) {
if (!pVideo->errCode)
pVideo->errCode = TEMP_REF; /* No pVideo->currTempRef corresponding to the display one */
SetErrorCode(ERR_NO_TEMPORAL_REFERENCE);
}
else {
pVideo->pNextDisplay->tempRef = 1025;
// to release the previous pointer for next decoding
pVideo->pNextDisplay = &pVideo->pictArray[index];
if ( pVideo->pNextDisplay->validPTS == FALSE ) {
/* PTS not available: compute a theoretical value */
WORD lattency = 3000; /* two 60Hz fields lattency */
if ( pVideo->StreamInfo.displayMode == 0 )
lattency = 3600; /* two 50Hz fields lattency */
pVideo->pNextDisplay->dwPTS = pVideo->pCurrDisplay->dwPTS + lattency;
// HostDirectPutChar('?', BLACK, LIGHTGREEN);
}
else{
// HostDirectPutChar('G', BLACK, LIGHTGREEN);
}
// set next display pointer
pVideo->currTempRef = pVideo->pictArray[index].tempRef;
pVideo->pictArray[index].tempRef = 1024;
/* this pVideo->currTempRef must not interfer on next tests */
}
}
//----------------------------------------------------------------------------
// Set parameters related to picture size
//----------------------------------------------------------------------------
/*
This routine will always program the sample rate converter
in order to display 720 horizontal pixels
*/
void FARAPI VideoSetPictureSize(void)
{
WORD compute, comput1;
// If PAL Switch on optimization
if ( pVideo->StreamInfo.frameRate == 3)
{
// Choose B Optimization for PAL for both Luma and Chroma
BoardWriteVideo(CFG_BFS,NB_ROW_OF_MB);
// Select Full Res vertical filter without interpolation
// Interpollation NOT ALLOWED if Optimization
pVideo->fullVerFilter = 0x01;
}
if ( (pVideo->StreamInfo.horSize > 720 ) ||
(pVideo->StreamInfo.verSize > 576 ))
{
if ( !pVideo->errCode )
pVideo->errCode = HIGH_CCIR601; // picture size higher than CCIR601 format
SetErrorCode(ERR_HIGHER_THAN_CCIR601);
return;
}
// set SRC depending on the horizontal size in order to display 720
// pixels
if ( pVideo->StreamInfo.horSize < 720 ) {
// lsr = 256 * (pVideo->StreamInfo.horSize-4) / (display size - 1)
VideoSetSRC(pVideo->StreamInfo.horSize, 720);
}
else {
VideoSRCOff();
}
if ( ( pVideo->StreamInfo.horSize >= 544 ) &&
( ( pVideo->StreamInfo.pixelRatio == 0x3 ) ||
( pVideo->StreamInfo.pixelRatio == 0x6 ) ) )
{
// picture size = 720 but pixel aspect ratio is 16/9
// Program the SRC for display on a 4/3 screen
// 544 pixels of the decoded picture extended into 720 pixels
// for display
VideoSetSRC(544, 720);
}
// set vertical filter and half/full resolution depending on the
// vertical picture size
if ( pVideo->StreamInfo.verSize > 288 ) {
// typically 480 or 576 lines
VideoSetFullRes();
}
else {
// typically 240 or 288 lines
// VideoSetFullRes(pVideo);
VideoSetHalfRes();
}
// set picture sizes into the decoder
comput1 = pVideo->StreamInfo.horSize + 15; // Horizontal size + 15
comput1 = ( comput1 >> 4 ) & 0xFF; // divide by 16
BoardWriteVideo ( DFW, (BYTE)comput1 );
// Decoded Frame Width in number of MB
compute = ( pVideo->StreamInfo.verSize + 15 ) >> 4;
compute = ( compute * comput1 ) & 0x3FFF;
BoardWriteVideo ( DFS, (BYTE)( ( compute >> 8 ) & 0xFF ) );
/* Decoded Frame Size in number of MB */
BoardWriteVideo ( DFS , (BYTE)( compute & 0xFF ) );
BoardWriteVideo ( VID_DFA , 0 );
BoardWriteVideo ( VID_DFA , 0 );
BoardWriteVideo ( VID_XFW, (BYTE)comput1 );
BoardWriteVideo ( VID_XFS, (BYTE)( ( compute >> 8 ) & 0xFF ) );
BoardWriteVideo ( VID_XFS, (BYTE)( compute & 0xFF ) );
BoardWriteVideo ( VID_XFA , 0 );
BoardWriteVideo ( VID_XFA , 0 );
}
//----------------------------------------------------------------------------
// store the next pan vector
//----------------------------------------------------------------------------
static void NEARAPI VideoSetPSV(void)
{
}
//----------------------------------------------------------------------------
// Enable/disable the SRC
//----------------------------------------------------------------------------
void FARAPI VideoSwitchSRC (void)
{
if (pVideo->useSRC != 0x0) {
pVideo->currDCF = pVideo->currDCF ^ DSR; /* Switch SRC */
BoardWriteVideo (DCF, 0);
BoardWriteVideo (DCF + 1, (BYTE)(pVideo->currDCF));
}
else {
// what ?
}
}
//----------------------------------------------------------------------------
// enable the SRC
//----------------------------------------------------------------------------
static void NEARAPI VideoSRCOn(void)
{
pVideo->useSRC = 0xFF;
pVideo->currDCF = pVideo->currDCF & ~DSR ; /* Enable SRC */
BoardWriteVideo ( DCF, 0 );
BoardWriteVideo ( DCF + 1, (BYTE)(pVideo->currDCF));
}
//----------------------------------------------------------------------------
// Disable the SRC
//----------------------------------------------------------------------------
static void NEARAPI VideoSRCOff (void)
{
pVideo->useSRC = 0x00;
pVideo->currDCF = pVideo->currDCF | DSR ; /* Enable SRC */
BoardWriteVideo ( DCF, 0 );
BoardWriteVideo ( DCF + 1, (BYTE)(pVideo->currDCF));
}
//----------------------------------------------------------------------------
// display a full screen OSD with a uniform color (just as example) */
//----------------------------------------------------------------------------
/*
color 0 is green
color 1 is yellow
color 2 is cyan
color 3 is magenta
the OSD area is here defined from address zero
in normal application this area is reserved for the bit buffer
and the OSD will be typically defined after the bit buffer.
Note: The bit buffer is defined in multiple of 256 bytes while
MWP, OEP and OOP are memory addresses in mulitple of 64 bits
*/
static void NEARAPI VideoFullOSD (WORD col)
{
long big;
WORD counter;
VideoSetMWP(0L);
counter = 0;
while ( !VideoMemWriteFifoEmpty()) {
counter ++;
if (counter == 0xFF) {
pVideo->errCode = BAD_MEM_V;
SetErrorCode(ERR_MEM_WRITE_FIFO_NEVER_EMPTY);
return ;
}
}
BoardWriteVideo ( MWF, 19 ); /* line 19 */
BoardWriteVideo ( MWF, 0x1 ); /* stop row */
BoardWriteVideo ( MWF, 0x02 ); /* 19 + 240 - 1 */
BoardWriteVideo ( MWF, 0x00 ); /* start column */
BoardWriteVideo ( MWF, 100 ); /* column 100 */
BoardWriteVideo ( MWF, 0x3 ); /* stop column = 100 + 700 - 1=
* 31F */
BoardWriteVideo ( MWF, 0x1F ); /* end init display size and
* position */
BoardWriteVideo ( MWF, 0x90 ); /* color 0 = green */
BoardWriteVideo ( MWF, 0x32 );
BoardWriteVideo ( MWF, 0xD0 ); /* color 1 = yellow */
BoardWriteVideo ( MWF, 0x19 );
BoardWriteVideo ( MWF, 0xA0 ); /* color 2 = cyan */
BoardWriteVideo ( MWF, 0xA1 );
BoardWriteVideo ( MWF, 0x60 ); /* color 3 = magenta */
BoardWriteVideo ( MWF, 0xDE ); // 6/D/E
if ( col == 1 )
col = 0x55;
else if ( col == 2 )
col = 0xAA;
else if ( col == 3 )
col = 0xFF;
for ( big = 0; big < 42000L; big++ ) // 42000 = 240 * 700 / 4
{
BoardWriteVideo ( MWF, (BYTE)col );
// select color
}
for ( big = 0; big < 8; big++ ) // add a dummy window outside
// the display
BoardWriteVideo ( MWF, 0xFF );
// to stop OSD
VideoInitOEP ( 0 ); // set OEP and OOP to start of
// bit map address
BoardWriteVideo ( DCF, 0 );
BoardWriteVideo ( DCF + 1, (BYTE)(pVideo->currDCF | 0x30));
// enable OSD
}