//***************************************************************************
//
// FileName:
// $Workfile: zivabrd.cpp $
//
// Author:
// TOSHIBA [PCS](PSY) Seiichi Nakamura
// Copyright (c) 1997 TOSHIBA CORPORATION
//
// Description:
//
//***************************************************************************
// $Header: /DVD Drivers/ZiVA.WDM/zivabrd.cpp 66 98/10/15 12:20p Yagi $
// $Modtime: 98/10/13 12:02p $
// $Nokeywords:$
//***************************************************************************
#include "includes.h"
#include "ioif.h"
#include "zivachip.h"
#include "adv.h"
#include "mixhal.h"
// by oka
#include "userdata.h"
#include "zivabrd.h"
#include "timeout.h"
#include "dramcfg.h"
//***************************************************************************
// IMBoardListItem Help Class
//***************************************************************************
CList::CList( void ): pTopItem( NULL ), pCurrentItem( NULL )
{
};
void CList::Init( void )
{
pTopItem = NULL;
pCurrentItem = NULL;
};
BOOL CList::SearchItem( IMBoardListItem *pItem )
{
IMBoardListItem *pCurrent;
if( pTopItem == NULL )
return FALSE;
pCurrent = pTopItem;
while( pCurrent != NULL )
{
if( pCurrent == pItem )
return TRUE;
pCurrent = pCurrent->GetNext();
}
return FALSE;
};
IMBoardListItem *CList::SearchBottomItem( void )
{
IMBoardListItem *pCurrent;
if( pTopItem == NULL )
return NULL;
pCurrent = pTopItem;
while( pCurrent->GetNext() != NULL )
pCurrent = pCurrent->GetNext();
return pCurrent;
};
BOOL CList::AddItem( IMBoardListItem *pItem )
{
IMBoardListItem *pBottom;
if( SearchItem( pItem ) == TRUE )
return FALSE;
pItem->SetNext( NULL );
if( pTopItem == NULL )
{
pTopItem = pCurrentItem = pItem;
return TRUE;
};
pBottom = SearchBottomItem();
ASSERT( pBottom != NULL );
pBottom->SetNext( pItem );
return TRUE;
};
BOOL CList::DeleteItem( IMBoardListItem *pItem )
{
IMBoardListItem *pCurrent;
if( SearchItem( pItem ) == FALSE )
return FALSE;
if( pTopItem == pItem )
{
pTopItem = pTopItem->GetNext();
pItem->SetNext( NULL );
return TRUE;
};
pCurrent = pTopItem;
while( pCurrent->GetNext() != pItem )
pCurrent = pCurrent->GetNext();
pCurrent->SetNext( pItem->GetNext() );
pItem->SetNext( NULL );
return TRUE;
};
BOOL CList::SetCurrentToTop( void )
{
pCurrentItem = pTopItem;
return TRUE;
};
IMBoardListItem *CList::GetNext( void )
{
IMBoardListItem *pItem;
pItem = pCurrentItem;
if( pCurrentItem != NULL )
pCurrentItem = pCurrentItem->GetNext();
return pItem;
};
//***************************************************************************
// ZiVA Board Class
//***************************************************************************
//---------------------------------------------------------------------------
// CMPEGBoardHAL Constructor
//---------------------------------------------------------------------------
CMPEGBoardHAL::CMPEGBoardHAL()
{
m_pKernelObj = NULL; // KernelService Object
#ifdef POWERCHECK_BY_FLAG
m_PowerState = POWERSTATE_OFF;
#endif
m_DMABufferLinearAddr = 0; // DMA buffer addr
m_DMABufferPhysicalAddr = 0; // DMA buffer addr
m_EventIntMask = 0;
// by oka
m_ZivaPbtIntMask = 0;
for(DWORD i=0;i<24;i++)
m_MaskReference[i]=0;
m_PowerOnTime = 0;
m_NeedPowerOnDelay = FALSE;
m_WrapperType = WrapperType_VxD; // default WrapperType
};
//---------------------------------------------------------------------------
// CMPEGBoardHAL Destructor
//---------------------------------------------------------------------------
CMPEGBoardHAL::~CMPEGBoardHAL()
{
};
//---------------------------------------------------------------------------
// CMPEGBoardHAL Init
//---------------------------------------------------------------------------
HALRESULT CMPEGBoardHAL::Init( WRAPPERTYPE wraptype )
{
m_pKernelObj = NULL; // KernelService Object
m_DMABufferLinearAddr = 0; // DMA buffer addr
m_DMABufferPhysicalAddr = 0; // DMA buffer addr
m_EventIntMask = 0;
m_WrapperType = wraptype;
// by oka
m_ZivaPbtIntMask = 0;
for(DWORD i=0;i<24;i++)
m_MaskReference[i]=0;
m_PowerOnTime = 0;
m_NeedPowerOnDelay = FALSE;
// by oka
m_CCRingBufferStart = 0xFFFFFFFF;
m_CCDataPoint = m_CCDataNumber = m_CCRingBufferNumber = 0;
m_CCsend_point = m_CCpending = m_CCnumber = 0;
m_SendDataEventList.Init();
m_StartVOBUEventList.Init();
m_EndVOBEventList.Init();
m_VUnderFlowEventList.Init();
m_AUnderFlowEventList.Init();
m_SPUnderFlowEventList.Init();
m_VOverFlowEventList.Init();
m_AOverFlowEventList.Init();
m_SPOverFlowEventList.Init();
m_VideoProp.Init(); // Video Property Set
m_AudioProp.Init(); // Audio Property Set
m_SubpicProp.Init(); // Subpic Property Set
return HAL_SUCCESS;
};
//---------------------------------------------------------------------------
// IWrapperHAL SetKernelService
//---------------------------------------------------------------------------
HALRESULT CMPEGBoardHAL::SetKernelService( IKernelService *pKernelService )
{
ASSERT( m_pKernelObj == NULL );
m_pKernelObj = pKernelService;
ioif.Init( m_pKernelObj );
ziva.Init( m_pKernelObj, &ioif );
adv7175a.Init( m_pKernelObj, &ioif );
adv7170.Init( m_pKernelObj, &ioif );
m_Stream.Init( &ziva , m_pKernelObj , &ioif , this );
// LUKE BUG!!!!!!
{
BYTE Data;
m_pKernelObj->GetPCIConfigData( 0x44, &Data );
Data = (BYTE)( Data & 0xfb ); // reset bit 2(CLKON)
m_pKernelObj->SetPCIConfigData( 0x44, Data );
};
// Check sub device ID and select ADV device
{
WORD SubDevID;
m_pKernelObj->GetPCIConfigData( 0x2E, &SubDevID );
if( SubDevID==0x0001 ) // SantaClara2
{
adv = &adv7175a;
}
else
{
adv = &adv7170;
}
}
return HAL_SUCCESS;
};
//---------------------------------------------------------------------------
// IWrapperHAL SetSinkWrapper
//---------------------------------------------------------------------------
HALRESULT CMPEGBoardHAL::SetSinkWrapper( IMPEGBoardEvent *pMPEGBoardEvent )
{
ASSERT( m_pKernelObj != NULL );
ASSERT( pMPEGBoardEvent != NULL );
BOOL rc = FALSE;
CAutoHwInt hwintLock( m_pKernelObj );
switch( pMPEGBoardEvent->GetEventType() )
{
case WrapperEvent_StartVOBU:
rc = m_StartVOBUEventList.AddItem( pMPEGBoardEvent );
m_EventIntMask |= ( ZIVA_INT_GOPV | ZIVA_INT_NV );
break;
case WrapperEvent_EndVOB:
rc = m_EndVOBEventList.AddItem( pMPEGBoardEvent );
m_ZivaPbtIntMask |= PBT_INT_END_VOB; // by oka for PBT_INT_SRC
m_EventIntMask |= ZIVA_INT_AOR;
break;
case WrapperEvent_VUnderFlow:
rc = m_VUnderFlowEventList.AddItem( pMPEGBoardEvent );
m_EventIntMask |= ZIVA_INT_UND;
break;
case WrapperEvent_AUnderFlow:
rc = m_AUnderFlowEventList.AddItem( pMPEGBoardEvent );
m_EventIntMask |= ZIVA_INT_UND;
break;
case WrapperEvent_SPUnderFlow:
rc = m_SPUnderFlowEventList.AddItem( pMPEGBoardEvent );
m_EventIntMask |= ZIVA_INT_UND;
break;
case WrapperEvent_VOverFlow:
rc = m_VOverFlowEventList.AddItem( pMPEGBoardEvent );
m_EventIntMask |= ZIVA_INT_BUFF;
break;
case WrapperEvent_AOverFlow:
rc = m_AOverFlowEventList.AddItem( pMPEGBoardEvent );
m_EventIntMask |= ZIVA_INT_BUFF;
break;
case WrapperEvent_SPOverFlow:
rc = m_SPOverFlowEventList.AddItem( pMPEGBoardEvent );
m_EventIntMask |= ZIVA_INT_BUFF;
break;
// by oka
case WrapperEvent_ButtonActivate:
rc = m_ButtonActivteEventList.AddItem( pMPEGBoardEvent );
m_EventIntMask |= ZIVA_INT_HLI ;
break;
case WrapperEvent_NextPicture:
rc = m_NextPictureEventList.AddItem( pMPEGBoardEvent );
m_EventIntMask |= ZIVA_INT_PICD ;
break;
case WrapperEvent_UserData:
rc = m_UserDataEventList.AddItem( pMPEGBoardEvent );
//m_EventIntMask |= ZIVA_INT_USR | ZIVA_INT_VSYNC;
// by oka
if (!SetEventIntMask( ZIVA_INT_USR ))
{
DBG_BREAK();
return HAL_ERROR;
}
break;
// end
case WrapperEvent_VSync:
rc = m_VSyncEventList.AddItem( pMPEGBoardEvent );
if (!SetEventIntMask( ZIVA_INT_VSYNC ))
{
DBG_BREAK();
return HAL_ERROR;
}
// ziva.INT_MASK = GetEventIntMask();
break;
default:
DBG_BREAK();
return HAL_ERROR;
};
if( rc == FALSE )
{
DBG_BREAK();
return HAL_ERROR;
};
return HAL_SUCCESS;
};
//---------------------------------------------------------------------------
// IWrapperHAL UnsetSinkWrapper
//---------------------------------------------------------------------------
HALRESULT CMPEGBoardHAL::UnsetSinkWrapper( IMPEGBoardEvent *pMPEGBoardEvent )
{
ASSERT( m_pKernelObj != NULL );
ASSERT( pMPEGBoardEvent != NULL );
BOOL rc = FALSE;
CAutoHwInt hwintLock( m_pKernelObj );
switch( pMPEGBoardEvent->GetEventType() )
{
case WrapperEvent_StartVOBU:
rc = m_StartVOBUEventList.DeleteItem( pMPEGBoardEvent );
m_EventIntMask &= ~( ZIVA_INT_GOPV | ZIVA_INT_NV );
break;
case WrapperEvent_EndVOB:
rc = m_EndVOBEventList.DeleteItem( pMPEGBoardEvent );
m_EventIntMask &= ~ZIVA_INT_AOR;
m_ZivaPbtIntMask &= ~PBT_INT_END_VOB; // by oka for PBT_INT_SRC
break;
case WrapperEvent_VUnderFlow:
rc = m_VUnderFlowEventList.DeleteItem( pMPEGBoardEvent );
m_EventIntMask &= ~ZIVA_INT_UND;
break;
case WrapperEvent_AUnderFlow:
rc = m_AUnderFlowEventList.DeleteItem( pMPEGBoardEvent );
m_EventIntMask &= ~ZIVA_INT_UND;
break;
case WrapperEvent_SPUnderFlow:
rc = m_SPUnderFlowEventList.DeleteItem( pMPEGBoardEvent );
m_EventIntMask &= ~ZIVA_INT_UND;
break;
case WrapperEvent_VOverFlow:
rc = m_VOverFlowEventList.DeleteItem( pMPEGBoardEvent );
m_EventIntMask &= ~ZIVA_INT_BUFF;
break;
case WrapperEvent_AOverFlow:
rc = m_AOverFlowEventList.DeleteItem( pMPEGBoardEvent );
m_EventIntMask &= ~ZIVA_INT_BUFF;
break;
case WrapperEvent_SPOverFlow:
rc = m_SPOverFlowEventList.DeleteItem( pMPEGBoardEvent );
m_EventIntMask &= ~ZIVA_INT_BUFF;
break;
// by oka
case WrapperEvent_ButtonActivate:
rc = m_ButtonActivteEventList.DeleteItem( pMPEGBoardEvent );
m_EventIntMask &= ~ZIVA_INT_HLI ;
break;
case WrapperEvent_NextPicture:
rc = m_NextPictureEventList.DeleteItem( pMPEGBoardEvent );
m_EventIntMask &= ~ZIVA_INT_PICD ;
break;
case WrapperEvent_UserData:
rc = m_UserDataEventList.DeleteItem( pMPEGBoardEvent );
//m_EventIntMask &= ~(ZIVA_INT_USR | ZIVA_INT_VSYNC);
// by oka
if (!UnsetEventIntMask( ZIVA_INT_USR ))
{
DBG_BREAK();
return HAL_ERROR;
}
break;
// end
case WrapperEvent_VSync:
rc = m_VSyncEventList.DeleteItem( pMPEGBoardEvent );
if (!UnsetEventIntMask( ZIVA_INT_VSYNC ))
{
DBG_BREAK();
return HAL_ERROR;
}
break;
default:
DBG_BREAK();
return HAL_ERROR;
};
if( rc == FALSE )
{
DBG_BREAK();
return HAL_ERROR;
};
return HAL_SUCCESS;
};
//---------------------------------------------------------------------------
// IWrapperHAL HALHwInterrupt
//---------------------------------------------------------------------------
HALRESULT CMPEGBoardHAL::HALHwInterrupt( void )
{
ASSERT( m_pKernelObj != NULL );
// POWERSTATE PowerState;
// GetPowerState( &PowerState );
// if( PowerState!=POWERSTATE_ON )
// return( HAL_IRQ_OTHER );
WORD wLukeIntFlag;
// get interrupt flag register from luke
wLukeIntFlag = ioif.luke2.IO_INTF;
if( wLukeIntFlag==0xFFFF ) // Yagi 97.09.24
return( HAL_IRQ_OTHER ); //
// Clear interrupt flag
ioif.luke2.IO_INTF = (WORD)(wLukeIntFlag & 0x039f);
// STCREFINT (STC Reference interrupt flag )
if( (wLukeIntFlag & 0x200 ) != 0 )
{
};
// MBAT ( Master Abort Occur interrupt flag ) this interrupt is ERROR!!!
if( (wLukeIntFlag & 0x100 ) != 0 )
{
BYTE Data;
// Config Data Master and Target Abort clear
m_pKernelObj->GetPCIConfigData( 0x07, &Data );
m_pKernelObj->SetPCIConfigData( 0x07, Data );
};
// STCINT( System timer interrupt flag )
if( (wLukeIntFlag & 0x80 ) != 0 )
{
};
// VS_INT( v-sync interrupt flag )
if( (wLukeIntFlag & 0x10 ) != 0 )
{
};
// VD_INT( video decoder interrut flag )
if( (wLukeIntFlag & 0x08 ) != 0 )
{
DWORD dwZiVAIntFlag;
dwZiVAIntFlag = ziva.INT_STATUS & ziva.INT_MASK;
CheckZiVAInterrupt( dwZiVAIntFlag );
// Clear ZiVA Interrupt
ziva.Host_Control = (ziva.Host_Control & 0xFFFFFFFC) | 0x82;
// Clear Ziva Interrupt Source
ziva.HLI_INT_SRC = 0;
ziva.BUFF_INT_SRC = 0;
ziva.UND_INT_SRC = 0;
ziva.AOR_INT_SRC = 0;
ziva.AEE_INT_SRC = 0;
ziva.ERR_INT_SRC = 0;
ziva.INT_STATUS = 0;
};
// MST_ABT( bus-master DMA software abort )
if( (wLukeIntFlag & 0x04 ) != 0 )
{
IHALBuffer *pFinishBuff;
DWORD Num, DmaNo ;
Num = m_Stream.m_DmaFifo.GetItemNum();
for( DWORD i = 0 ; i < Num ; i ++ )
{
m_Stream.m_DmaFifo.GetItem( &DmaNo );
pFinishBuff = m_Stream.DMAFinish( DmaNo );
if( pFinishBuff != NULL )
NotifyEvent( &m_SendDataEventList , (VOID *)pFinishBuff );
};
m_NaviCount = 0;
m_Stream.m_DmaFifo.Flush();
Num = m_Stream.m_HalFifo.GetItemNum();
for( i = 0 ; i < Num ; i ++ )
{
m_Stream.m_HalFifo.GetItem( &pFinishBuff );
if( pFinishBuff != NULL )
NotifyEvent( &m_SendDataEventList , (VOID *)pFinishBuff );
};
m_Stream.m_HalFifo.Flush();
SetMasterAbortEvent();
};
// check Data complete
if( (wLukeIntFlag & 0x03 ) != 0 )
{
BYTE Num = 0;
if( (wLukeIntFlag & 0x02 ) != 0 )Num ++;
if( (wLukeIntFlag & 0x01 ) != 0 )Num ++;
for( int i = 0 ; i < Num; i ++ )
{
DWORD DMANo;
if( m_Stream.m_DmaFifo.GetItemNum() != 0 )
{
m_Stream.m_DmaFifo.GetItem( &DMANo );
switch( DMANo )
{
case 0:
// MST_INT0( bus-master DMA complete interrupt flag )
if( (wLukeIntFlag & 0x01 ) != 0 )
{
IHALBuffer *pFinishBuff;
pFinishBuff = m_Stream.DMAFinish( 0 );
if( pFinishBuff != NULL )
NotifyEvent( &m_SendDataEventList , (VOID *)pFinishBuff );
}
else
{
DBG_PRINTF( ("status ERROR!!! LINE = %d\r\n", __LINE__ ));
DBG_BREAK();
};
break;
case 1:
// MST_INT1( bus-master DMA complete interrupt flag )
if( (wLukeIntFlag & 0x02 ) != 0 )
{
IHALBuffer *pFinishBuff;
pFinishBuff = m_Stream.DMAFinish( 1 );
if( pFinishBuff != NULL )
NotifyEvent( &m_SendDataEventList , (VOID *)pFinishBuff );
}
else
{
DBG_PRINTF( ("status ERROR!!! LINE = %d\r\n", __LINE__ ));
DBG_BREAK();
};
break;
default:
DBG_PRINTF( ("status ERROR!!! LINE = %d\r\n", __LINE__ ));
ASSERT( 0 == 1 );
};
};
};
m_Stream.DeFifo();
};
if( (wLukeIntFlag & 0x039f) != 0 )
return HAL_IRQ_MINE;
return HAL_IRQ_OTHER;
};
//---------------------------------------------------------------------------
// IWrapperHAL QueryDMABufferSize
//---------------------------------------------------------------------------
HALRESULT CMPEGBoardHAL::QueryDMABufferSize( DWORD *Size, DWORD *BFlag )
{
*Size = 2048; // 2048 byte
*BFlag = 0;
return HAL_SUCCESS;
};
//---------------------------------------------------------------------------
// IWrapperHAL QueryDMABufferSize
//---------------------------------------------------------------------------
HALRESULT CMPEGBoardHAL::SetDMABuffer( DWORD LinearAddr, DWORD physicalAddr )
{
m_DMABufferLinearAddr = LinearAddr;
m_DMABufferPhysicalAddr = physicalAddr;
return HAL_SUCCESS;
};
//---------------------------------------------------------------------------
// IWrapperHAL GetCapability 1998.03.27 H.Yagi
//---------------------------------------------------------------------------
HALRESULT CMPEGBoardHAL::GetCapability( CAPSTYPE PropType, DWORD *pPropType )
{
ASSERT( m_pKernelObj != NULL );
HALRESULT ret;
WORD DeviceID, SubDevID, VenderID, SubVenID;
ret = HAL_SUCCESS;
m_pKernelObj->GetPCIConfigData( 0x00, &VenderID );
m_pKernelObj->GetPCIConfigData( 0x02, &DeviceID );
m_pKernelObj->GetPCIConfigData( 0x2C, &SubVenID );
m_pKernelObj->GetPCIConfigData( 0x2E, &SubDevID );
switch( PropType ){
case VideoProperty:
*pPropType = VideoProperty_TVSystem_BIT |
VideoProperty_AspectRatio_BIT |
VideoProperty_DisplayMode_BIT |
VideoProperty_Resolution_BIT |
VideoProperty_DigitalOut_BIT |
VideoProperty_DigitalPalette_BIT |
VideoProperty_APS_BIT |
VideoProperty_ClosedCaption_BIT |
// VideoProperty_OutputSource_BIT |
VideoProperty_CompositeOut_BIT |
VideoProperty_SVideoOut_BIT |
VideoProperty_SkipFieldControl_BIT |
VideoProperty_FilmCamera_BIT |
VideoProperty_SquarePixel_BIT;
if( VenderID==0x1179 && DeviceID==0x0407 ){ // SantaClara2 or SanJode
switch( SubDevID ){
case 0x0001: // SantaClara2
case 0x0003: // SanJose
*pPropType |= VideoProperty_OutputSource_BIT;
break;
}
}
ret = HAL_SUCCESS;
break;
case AudioProperty:
case SubpicProperty:
ret = HAL_NOT_IMPLEMENT;
break;
case DigitalVideoOut:
*pPropType = DigitalVideoOut_ZV_BIT |
DigitalVideoOut_LPB08_BIT |
DigitalVideoOut_LPB16_BIT |
DigitalVideoOut_VMI_BIT |
DigitalVideoOut_AMCbt_BIT |
DigitalVideoOut_AMC656_BIT |
DigitalVideoOut_DAV2_BIT |
DigitalVideoOut_CIRRUS_BIT ;
// Check SubDevID
switch( SubDevID ){
case 0x0001: // SantaClara2
case 0x0003: // SanJose
*pPropType = DigitalVideoOut_ZV_BIT;
break;
}
ret = HAL_SUCCESS;
break;
}
return ret;
};
//---------------------------------------------------------------------------
// IClassLibHAL GetMixHALStream
//---------------------------------------------------------------------------
HALRESULT CMPEGBoardHAL::GetMixHALStream( IHALStreamControl **ppHALStreamControl )
{
ASSERT( m_pKernelObj != NULL );
*ppHALStreamControl = (IHALStreamControl *)&m_Stream;
return HAL_SUCCESS;
};
//---------------------------------------------------------------------------
// IClassLibHAL GetVideoHALStream
//---------------------------------------------------------------------------
HALRESULT CMPEGBoardHAL::GetVideoHALStream( IHALStreamControl **ppHALStreamControl )
{
return HAL_NOT_IMPLEMENT;
};
//---------------------------------------------------------------------------
// IClassLibHAL GetAudioHALStream
//---------------------------------------------------------------------------
HALRESULT CMPEGBoardHAL::GetAudioHALStream( IHALStreamControl **ppHALStreamControl )
{
return HAL_NOT_IMPLEMENT;
};
//---------------------------------------------------------------------------
// IClassLibHAL GetSubpicHALStream
//---------------------------------------------------------------------------
HALRESULT CMPEGBoardHAL::GetSubpicHALStream( IHALStreamControl **ppHALStreamControl )
{
return HAL_NOT_IMPLEMENT;
};
//---------------------------------------------------------------------------
// IClassLibHAL SetSinkClassLib
//---------------------------------------------------------------------------
HALRESULT CMPEGBoardHAL::SetSinkClassLib( IMPEGBoardEvent *pMPEGBoardEvent )
{
if( pMPEGBoardEvent->GetEventType() == ClassLibEvent_SendData )
{
if( m_SendDataEventList.AddItem( pMPEGBoardEvent ) == FALSE )
{
DBG_BREAK();
return HAL_ERROR;
};
return HAL_SUCCESS;
}
DBG_BREAK();
return HAL_ERROR;
};
//---------------------------------------------------------------------------
// IClassLibHAL UnsetSinkClassLib
//---------------------------------------------------------------------------
HALRESULT CMPEGBoardHAL::UnsetSinkClassLib( IMPEGBoardEvent *pMPEGBoardEvent )
{
if( pMPEGBoardEvent->GetEventType() == ClassLibEvent_SendData )
{
if( m_SendDataEventList.DeleteItem( pMPEGBoardEvent ) == FALSE )
{
DBG_BREAK();
return HAL_ERROR;
};
return HAL_SUCCESS;
}
DBG_BREAK();
return HAL_ERROR;
};
//---------------------------------------------------------------------------
// IClassLibHAL SetPowerState
//---------------------------------------------------------------------------
HALRESULT CMPEGBoardHAL::SetPowerState( POWERSTATE dwSwitch )
{
ASSERT( m_pKernelObj != NULL );
// CAutoHwInt hwintLock( m_pKernelObj );
// POWERSTATE PowerState;
// GetPowerState( &PowerState );
// DBG_PRINTF( ("HAL:SetPowerState: OldState = %d, NewState = %d\n", PowerState, dwSwitch));
/*
if( dwSwitch == PowerState )
return HAL_SUCCESS;
*/
if( dwSwitch == POWERSTATE_ON )
{
BYTE Data;
#ifndef _WDMDDK_
m_pKernelObj->DisableHwInt();
#endif
// reset bit 7(PWROFF) and set bit 2(CLKON)
m_pKernelObj->GetPCIConfigData( 0x44, &Data );
Data = (BYTE)( (Data & 0x7f) | 0x04 );
m_pKernelObj->SetPCIConfigData( 0x44, Data );
// 10 msec wait.
m_pKernelObj->Sleep( 10 );
// set bit 6(BOFFZ) and bit 5(SRESET)
m_pKernelObj->GetPCIConfigData( 0x44, &Data );
Data = (BYTE)( Data | 0x60 );
m_pKernelObj->SetPCIConfigData( 0x44, Data );
// 1 msec wait.
m_pKernelObj->Sleep( 1 );
// reset bit 5(SRESET)
m_pKernelObj->GetPCIConfigData( 0x44, &Data );
Data = (BYTE)( Data & 0xdf );
m_pKernelObj->SetPCIConfigData( 0x44, Data );
#ifndef _WDMDDK_
m_pKernelObj->EnableHwInt();
#endif
// Download ZiVA microcode
switch( m_VideoProp.m_TVSystem )
{
case TV_NTSC:
if( ziva.WriteMicrocode( 0 ) == FALSE )
{
DBG_BREAK();
return HAL_ERROR;
};
break;
case TV_PALB: case TV_PALD: case TV_PALG:
case TV_PALH: case TV_PALI: case TV_PALM:
case TV_PALN:
if( ziva.WriteMicrocode( 1 ) == FALSE )
{
DBG_BREAK();
return HAL_ERROR;
};
break;
default:
DBG_BREAK();
return HAL_ERROR;
};
// HOST_control reset ZiVA and translate Run mode.
ziva.Host_Control |= 0x00000022;
// HOST_OPTIONS set by WrapperType. 98.09.25 by H.Yagi
if( m_WrapperType == WrapperType_WDM ){
ziva.HOST_OPTIONS |= 0x010;
}
#ifdef POWERCHECK_BY_FLAG
m_PowerState = POWERSTATE_ON;
#endif
m_Stream.SetTransferMode( HALSTREAM_DVD_MODE );
// setup properties
SetVideoProperty_TVSystem( (void *)&m_VideoProp.m_TVSystem );
SetVideoProperty_AspectRatio( (void *)&m_VideoProp.m_AspectRatio );
SetVideoProperty_DisplayMode( (void *)&m_VideoProp.m_DisplayMode );
SetVideoProperty_Resolution( (void *)&m_VideoProp.m_Size );
SetVideoProperty_DigitalOut( (void *)&m_VideoProp.m_DigitalOut );
for( int i = 0; i < 3; i ++ )
{
Digital_Palette Pal;
Pal.Select = (VIDEOPALETTETYPE)i;
Pal.pPalette = m_VideoProp.m_DigitalPalette[i];
SetVideoProperty_DigitalPalette( (void *)&Pal );
};
SetVideoProperty_APS( (void *)&m_VideoProp.m_APS );
SetVideoProperty_ClosedCaption( (void *)&m_VideoProp.m_ClosedCaption );
SetVideoProperty_OutputSource( (void *)&m_VideoProp.m_OutputSource );
SetVideoProperty_CompositeOut( (void *)&m_VideoProp.m_CompositeOut );
SetVideoProperty_SVideoOut( (void *)&m_VideoProp.m_SVideoOut );
SetVideoProperty_SkipFieldControl( (void *)&m_VideoProp.m_SkipFieldControl );
SetAudioProperty_Type( (void *)&m_AudioProp.m_Type );
SetAudioProperty_Number( (void *)&m_AudioProp.m_StreamNo );
SetAudioProperty_Volume( (void *)&m_AudioProp.m_Volume );
SetAudioProperty_Sampling( (void *)&m_AudioProp.m_Sampling );
SetAudioProperty_Channel( (void *)&m_AudioProp.m_ChannelNo );
SetAudioProperty_Quant( (void *)&m_AudioProp.m_Quant );
SetAudioProperty_AudioOut( (void *)&m_AudioProp.m_OutType );
SetAudioProperty_Cgms( (void *)&m_AudioProp.m_Cgms );
SetAudioProperty_AnalogOut( (void *)&m_AudioProp.m_AnalogOut );
SetAudioProperty_DigitalOut( (void *)&m_AudioProp.m_DigitalOut );
SetAudioProperty_AC3DRangeLowBoost( (void *)&m_AudioProp.m_AC3DRangeLowBoost );
SetAudioProperty_AC3DRangeHighCut( (void *)&m_AudioProp.m_AC3DRangeHighCut );
SetAudioProperty_AC3OperateMode( (void *)&m_AudioProp.m_AC3OperateMode );
SetSubpicProperty_Number( (void *)&m_SubpicProp.m_StreamNo);
SetSubpicProperty_Palette( (void *)&m_SubpicProp.m_Palette );
SetSubpicProperty_Hilight( (void *)&m_SubpicProp.m_Hlight );
SetSubpicProperty_State( (void *)&m_SubpicProp.m_OutType );
// Audio Mute Off
// ioif.luke2.IO_CONT = ioif.luke2.IO_CONT & 0xffffffb8;
ioif.luke2.IO_CONT = ( (ioif.luke2.IO_CONT & 0xffffffb8)|0x40 ); // *Luke2Z spec is changed.
// power on delay
m_NeedPowerOnDelay = TRUE;
m_pKernelObj->GetTickCount( &m_PowerOnTime );
//by oka
m_CCstart = ziva.USER_DATA_BUFFER_START;
m_CCend = ziva.USER_DATA_BUFFER_END;
m_OSDStartAddr = ziva.OSD_BUFFER_START;
m_OSDEndAddr = ziva.OSD_BUFFER_END;
// end
return HAL_SUCCESS;
};
if( dwSwitch == POWERSTATE_OFF )
{
BYTE Data;
#ifndef _WDMDDK_
m_pKernelObj->DisableHwInt();
#endif
// Audio Mute
// ioif.luke2.IO_CONT = (ioif.luke2.IO_CONT & 0xffffff00) | 0x40;
ioif.luke2.IO_CONT = (ioif.luke2.IO_CONT & 0xffffff00); // *Luke2Z spec is changed.
// Check ZV Enable bit
m_pKernelObj->GetPCIConfigData( 0x44, &Data );
if( (Data & 0x01) != 0 )
{
Data = (BYTE)( Data & 0xfe );
m_pKernelObj->SetPCIConfigData( 0x44, Data );
};
// reset bit 6(BOFFZ)
m_pKernelObj->GetPCIConfigData( 0x44, &Data );
Data = (BYTE)( Data & 0xbf );
m_pKernelObj->SetPCIConfigData( 0x44, Data );
// reset bit 2(CLKON) and set bit 7(PWROFF)
m_pKernelObj->GetPCIConfigData( 0x44, &Data );
Data = (BYTE)( (Data & 0xfb) | 0x80 );
m_pKernelObj->SetPCIConfigData( 0x44, Data );
#ifdef POWERCHECK_BY_FLAG
m_PowerState = POWERSTATE_OFF;
#endif
#ifndef _WDMDDK_
m_pKernelObj->EnableHwInt();
#endif
return HAL_SUCCESS;
};
return HAL_INVALID_PARAM;
};
//---------------------------------------------------------------------------
// IClassLibHAL GetPowerState
//---------------------------------------------------------------------------
HALRESULT CMPEGBoardHAL::GetPowerState( POWERSTATE *pSwitch )
{
ASSERT( m_pKernelObj != NULL );
#ifdef POWERCHECK_BY_FLAG
*pSwitch = m_PowerState;
return HAL_SUCCESS;
#else
BYTE Data;
m_pKernelObj->GetPCIConfigData( 0x44, &Data );
if( ( Data & 0x80 ) == 0 )
{
if( ( ziva.Host_Control & 0xc00000 ) == 0 )
*pSwitch = POWERSTATE_ON;
else
{
SetPowerState( POWERSTATE_OFF );
*pSwitch = POWERSTATE_OFF;
};
}
else
*pSwitch = POWERSTATE_OFF;
#endif
return HAL_SUCCESS;
};
//---------------------------------------------------------------------------
// IClassLibHAL SetSTC
//---------------------------------------------------------------------------
HALRESULT CMPEGBoardHAL::SetSTC( DWORD STCValue )
{
POWERSTATE PowerState;
GetPowerState( &PowerState );
if( PowerState != POWERSTATE_ON )
return HAL_POWEROFF;
ziva.MRC_PIC_STC = STCValue;
return HAL_SUCCESS;
};
//---------------------------------------------------------------------------
// IClassLibHAL GetSTC
//---------------------------------------------------------------------------
HALRESULT CMPEGBoardHAL::GetSTC( DWORD *pSTCValue )
{
POWERSTATE PowerState;
GetPowerState( &PowerState );
if( PowerState != POWERSTATE_ON )
return HAL_POWEROFF;
*pSTCValue = ziva.MRC_PIC_STC;
return HAL_SUCCESS;
};
//---------------------------------------------------------------------------
// Send HAL Notify
//---------------------------------------------------------------------------
void CMPEGBoardHAL::NotifyEvent( CList *pList, VOID *Ret )
{
IMPEGBoardEvent *pEvent;
pList->SetCurrentToTop();
while( ( pEvent = (IMPEGBoardEvent *)pList->GetNext() ) != NULL )
pEvent->Advice( Ret );
};
//---------------------------------------------------------------------------
// Check ZIVA Interrupt(ZiVA Decoder To Host Interrupt Check )
//---------------------------------------------------------------------------
void CMPEGBoardHAL::CheckZiVAInterrupt( DWORD dwIntFlag )
{
// ERR: Bitstream data error has been deteced.
if( ( dwIntFlag & ZIVA_INT_ERR ) != 0 )
{
};
// PIC-V: Starting display of new picture.
if( ( dwIntFlag & ZIVA_INT_PICV ) != 0 )
{
// by oka
NotifyEvent( &m_NextPictureEventList, NULL );
};
// GOP-V: Starting display of first I-Picture after GOP startcode.
if( ( dwIntFlag & ZIVA_INT_GOPV ) != 0 )
{
for( DWORD i = 0 ; i < m_NaviCount; i ++ )
NotifyEvent( &m_StartVOBUEventList, NULL );
m_NaviCount = 0;
};
// SEQ-V: Starting display of first I-Pucture after sequence start-code.
if( ( dwIntFlag & ZIVA_INT_SEQV ) != 0 )
{
};
// END-V: Starting display of last picture before sequence-end startcode.
if( ( dwIntFlag & ZIVA_INT_ENDV ) != 0 )
{
};
// PIC-D: Completed picture decode.
if( ( dwIntFlag & ZIVA_INT_PICD ) != 0 )
{
};
// VSYNC: VSYNC pulse occurred.
if( ( dwIntFlag & ZIVA_INT_VSYNC ) != 0 )
{
// for VSyncEvent
NotifyEvent( &m_VSyncEventList, NULL );
// by oka
if( m_VideoProp.m_ClosedCaption == ClosedCaption_On ){
SendCCData();
}
/****** commented out by H.Yagi 98.05.13 **** start *****
DWORD Data;
switch( (DWORD)ziva.CURR_PIC_DISPLAYED )
{
case ADDR_PIC1_BUFFER_START:
Data = ziva.PIC1_TREF_PTYP_FLGS;
break;
case ADDR_PIC2_BUFFER_START:
Data = ziva.PIC2_TREF_PTYP_FLGS;
break;
case ADDR_PIC3_BUFFER_START:
Data = ziva.PIC3_TREF_PTYP_FLGS;
break;
default:
Data = 0;
};
static DWORD SkipCounter = 0;
static DWORD OldData = 0;
if( ( OldData & 0x40 ) == 0 && (Data & 0x40 ) != 0 )
SkipCounter = 5;
OldData = Data;
****** commented out by H.Yagi 98.05.13 **** end *****/
/*
// check Progressive and repeat_first
if( (Data & 0x50 ) == 0x50 )
{
if( ziva.VIDEO_FIELD == 0 ) // check Top field?
{
if( (Data & 0x20 ) == 0 && SkipCounter == 0 ) // check Top_Field_first = 1?
{
// Skip!!
SkipCounter = 5;
};
}
else // Bottom field.
{
if( (Data & 0x20 ) != 0 && SkipCounter == 0 ) // check Top_Field_first = 0?
{
// Skip!!
SkipCounter = 5;
};
};
};
*/
/****** commented out by H.Yagi 98.05.13 **** start *****
DWORD Flag;
ziva.ZiVAReadMemory( 0x210, &Flag );
// if( SkipCounter == 4 || SkipCounter ==3 || SkipCounter == 5 )
// if( Flag != 0 && SkipCounter == Flag )
if( Flag != 0 )
{
if( ( Flag & 0x01 ) != 0 && SkipCounter == 5 )
ioif.luke2.AVCONT |= 0x02;
if( ( Flag & 0x02 ) != 0 && SkipCounter == 4 )
ioif.luke2.AVCONT |= 0x02;
if( ( Flag & 0x04 ) != 0 && SkipCounter == 3 )
ioif.luke2.AVCONT |= 0x02;
if( ( Flag & 0x08 ) != 0 && SkipCounter == 2 )
ioif.luke2.AVCONT |= 0x02;
if( ( Flag & 0x10 ) != 0 && SkipCounter == 1 )
ioif.luke2.AVCONT |= 0x02;
};
if( SkipCounter > 0 )
SkipCounter --;
****** commented out by H.Yagi 98.05.13 **** end *****/
};
// AOR: VCD Mode: VCD sector address out of range in CDROM_MPEG mode
// PBT: DVD Mode: Delect VOBU_E_PTM
if( ( dwIntFlag & ZIVA_INT_AOR ) != 0 )
{
// by oka for END_VOB or NV_LBN
DWORD PbtInt = (m_ZivaPbtIntMask & ziva.PBT_INT_SRC);
// END_VOB
if ((PbtInt & PBT_INT_END_VOB) != 0)
{
ziva.INT_MASK &= (ULONG)(~ZIVA_INT_AOR);
NotifyEvent( &m_EndVOBEventList, NULL );
}
};
// UND: Input buffer underflow.
if( ( dwIntFlag & ZIVA_INT_UND ) != 0 )
{
DWORD UFlag = ziva.UND_INT_SRC;
// Check Video Underflow
if( (UFlag & 0x01) != 0 )
NotifyEvent( &m_VUnderFlowEventList , NULL );
// Check Audio Underflow
if( (UFlag & 0x02) != 0 )
NotifyEvent( &m_AUnderFlowEventList , NULL );
// Check SubPic Underflow
if( (UFlag & 0x04) != 0 )
NotifyEvent( &m_SPUnderFlowEventList , NULL );
};
// END-C: High-Priority command execution is complete.
if( ( dwIntFlag & ZIVA_INT_ENDC ) != 0 )
{
SetENDCEvent();
};
// RDY-S: Ready for data during CDROM_MPEG mode SlowMotion() or SingleStep() Commands.
if( ( dwIntFlag & ZIVA_INT_RDYS ) != 0 )
{
};
// SCN: A Scan() command has caused a transition to PAUSE()
if( ( dwIntFlag & ZIVA_INT_SCN ) != 0 )
{
};
// USR: User data is ready
if( ( dwIntFlag & ZIVA_INT_USR ) != 0 )
{
// by oka
SetUSRData();
};
// END-P: Entered PAUSE state.
if( ( dwIntFlag & ZIVA_INT_ENDP ) != 0 )
{
SetENDPEvent();
};
// END-D: a data transfer is complete, from either a Dump DumpData_VCD(),DumpData_DVD(),or ROMtoDRAM() command.
if( ( dwIntFlag & ZIVA_INT_ENDD ) != 0 )
{
};
// A/E/E: Deteced CD submode auto-pause, end of recoerd, or end of file.
if( ( dwIntFlag & ZIVA_INT_AEE ) != 0 )
{
};
// BUF-F: An input buffer is full or the video input buffer os fulling CDROM_MPEG mode SlowMotion() and SingleStep() commands.
if( ( dwIntFlag & ZIVA_INT_BUFF ) != 0 )
{
DWORD OFlag = ziva.BUFF_INT_SRC;
// Check Video OverFlow
if( (OFlag & 0x01) != 0 )
NotifyEvent( &m_VOverFlowEventList , NULL );
// Check Audio OverFlow
if( (OFlag & 0x02) != 0 )
NotifyEvent( &m_AOverFlowEventList , NULL );
// Check SubPic Underflow
if( (OFlag & 0x04) != 0 )
NotifyEvent( &m_SPOverFlowEventList , NULL );
};
// SEQ-E: A sequence_end_code startcode has been processed by the MPEG video decoder.
if( ( dwIntFlag & ZIVA_INT_SEQE ) != 0 )
{
};
// NV: an NV_PACK has benn received and parsed into DSI and PCI packets.
if( ( dwIntFlag & ZIVA_INT_NV ) != 0 )
{
m_NaviCount ++;
};
// HLI: a button activation highlight has just been displayed.
if( ( dwIntFlag & ZIVA_INT_HLI ) != 0 )
{
// by oka
DWORD Data;
Data = ziva.HLI_INT_SRC;
NotifyEvent( &m_ButtonActivteEventList, (PVOID)Data );
};
// RDY-D: The decoder is ready to receive data.
if( ( dwIntFlag & ZIVA_INT_RDYD ) != 0 )
{
SetRDYDEvent();
};
// Reserved.
if( ( dwIntFlag & ZIVA_INT_RESERV1 ) != 0 )
{
};
// AUD: A new audio frequency, sample size, or audio emphasis value was detected.
if( ( dwIntFlag & ZIVA_INT_AUD ) != 0 )
{
};
// INIT: Decoder microcode initialization is complete. Status Area is Valid. Decoder is ready to accept host commands.
if( ( dwIntFlag & ZIVA_INT_INIT ) != 0 )
{
};
};
//---------------------------------------------------------------------------
// WaitMasterAbort
//---------------------------------------------------------------------------
BOOL CMPEGBoardHAL::WaitMasterAbort( void )
{
// Wait Master Abort interrupt
CTimeOut TimeOut( 5000, 10, m_pKernelObj );
//#ifdef _WDMDDK_
// WORD wLukeIntFlag;
//#endif
while( TRUE )
{
if( IsMasterAbortOccurred() == TRUE )
break;
//#ifdef _WDMDDK_
// wLukeIntFlag = ioif.luke2.IO_INTF;
// if( (wLukeIntFlag & 0x04 ) != 0 )
// break;
//#endif
TimeOut.Sleep();
if( TimeOut.CheckTimeOut() == TRUE )
{
DBG_BREAK();
return FALSE;
};
};
return TRUE;
};
//---------------------------------------------------------------------------
// WaitWaitRDYD
//---------------------------------------------------------------------------
BOOL CMPEGBoardHAL::WaitRDYD( void )
{
// Wait RDY-D interrupt
CTimeOut TimeOut( 5000, 10, m_pKernelObj );
//#ifdef _WDMDDK_
// DWORD dwZiVAIntFlag;
//#endif
while( TRUE )
{
if( IsRDYDOccurred() == TRUE )
break;
//#ifdef _WDMDDK_
// dwZiVAIntFlag = ziva.INT_STATUS & ziva.INT_MASK;
// if( ( dwZiVAIntFlag & ZIVA_INT_RDYD ) != 0 )
// break;
//#endif
TimeOut.Sleep();
if( TimeOut.CheckTimeOut() == TRUE )
{
DBG_BREAK();
return FALSE;
};
};
return TRUE;
};
//---------------------------------------------------------------------------
// WaitWaitENDP
//---------------------------------------------------------------------------
BOOL CMPEGBoardHAL::WaitENDP( void )
{
// Wait END-P interrupt
CTimeOut TimeOut( 5000, 10, m_pKernelObj );
//#ifdef _WDMDDK_
// DWORD dwZiVAIntFlag;
//#endif
while( TRUE )
{
if( IsENDPOccurred() == TRUE )
break;
//#ifdef _WDMDDK_
// dwZiVAIntFlag = ziva.INT_STATUS & ziva.INT_MASK;
// if( ( dwZiVAIntFlag & ZIVA_INT_ENDP ) != 0 )
// break;
//#endif
TimeOut.Sleep();
if( TimeOut.CheckTimeOut() == TRUE )
{
DBG_BREAK();
return FALSE;
};
};
return TRUE;
};
//---------------------------------------------------------------------------
// WaitWaitENDC
//---------------------------------------------------------------------------
BOOL CMPEGBoardHAL::WaitENDC( void )
{
// Wait END-C interrupt
CTimeOut TimeOut( 5000, 10, m_pKernelObj );
//#ifdef _WDMDDK_
// DWORD dwZiVAIntFlag;
//// DWORD StatusPointer,Status;
//#endif
while( TRUE )
{
if( IsENDCOccurred() == TRUE )
break;
//#ifdef _WDMDDK_
// dwZiVAIntFlag = ziva.INT_STATUS & ziva.INT_MASK;
// if( ( dwZiVAIntFlag & ZIVA_INT_ENDC ) != 0 )
// break;
//
///*
// StatusPointer = Status = 0;
// ziva.ZiVAReadMemory(ADDR_STATUS_ADDRESS, &StatusPointer);
// if( StatusPointer != 0 )
// {
// ziva.ZiVAReadMemory(StatusPointer, &Status);
// if( Status == 0x04 )
// return TRUE;
// };
//*/
//#endif
TimeOut.Sleep();
if( TimeOut.CheckTimeOut() == TRUE )
{
DBG_BREAK();
return FALSE;
};
};
return TRUE;
};
//---------------------------------------------------------------------------
//
//---------------------------------------------------------------------------
void CMPEGBoardHAL::ClearMasterAbortEvent( void ){ fMasterAbortFlag = FALSE; };
void CMPEGBoardHAL::SetMasterAbortEvent( void ){ fMasterAbortFlag = TRUE; };
BOOL CMPEGBoardHAL::IsMasterAbortOccurred( void ) { return fMasterAbortFlag; };
void CMPEGBoardHAL::ClearRDYDEvent( void ){ fRDYDFlag = FALSE; };
void CMPEGBoardHAL::SetRDYDEvent( void ){ fRDYDFlag = TRUE; };
BOOL CMPEGBoardHAL::IsRDYDOccurred( void ) { return fRDYDFlag; };
void CMPEGBoardHAL::ClearENDPEvent( void ){ fENDPFlag = FALSE; };
void CMPEGBoardHAL::SetENDPEvent( void ){ fENDPFlag = TRUE; };
BOOL CMPEGBoardHAL::IsENDPOccurred( void ) { return fENDPFlag; };
void CMPEGBoardHAL::ClearENDCEvent( void ){ fENDCFlag = FALSE; };
void CMPEGBoardHAL::SetENDCEvent( void ){ fENDCFlag = TRUE; };
BOOL CMPEGBoardHAL::IsENDCOccurred( void ) { return fENDCFlag; };
//---------------------------------------------------------------------------
// CMPEGBoardHAL::SetUSRData
// by oka Closed Caption
//---------------------------------------------------------------------------
inline void CMPEGBoardHAL::SetUSRData( void )
{
// USER_DATA_WRITE�̃A�h���X����f�[�^�����o��
DWORD read, write;
read = ziva.USER_DATA_READ;
write = ziva.USER_DATA_WRITE;
// check header
DWORD header,data_size;
// DWORD header_type;
ziva.ZiVAReadMemory(read, &header);
if (read == 0xFFFFFFFF)
{
// FIFO overflow
//RETAILMSG(ZONE_TRACE,(TEXT("FIFO overflow \r\n")));
ziva.USER_DATA_READ = write;
//DBG_BREAK();
return;
}
ASSERT((header & 0xFFFF0000) >> 16 == 0xFEED);
// header_type = (header & 0x0000F000) >> 12;
data_size = (header & 0x00000FFF);
// RETAILMSG(1,(TEXT("start=%08X end=%08X read=%X header=%08X header_type=%01d size=%04X \r\n"),
// start, end, read, header, header_type, data_size ));
m_UserData.Init();
DWORD data_tmp;
DWORD point;
point = read;
DWORD count;
for(count=0;count<data_size;count+=4)
{
// for ring buffer
if (point+4 >= m_CCend)
{
point = m_CCstart;
} else {
point += 4;
}
// Get user data
ziva.ZiVAReadMemory(point, &data_tmp);
if (!(m_UserData.Set(data_tmp)))
{
//RETAILMSG(ZONE_ERROR, (TEXT("CMPEGBoardHAL::SetUSRData UserData size too Big!!\r\n")));
DBG_BREAK();
break;
}
}
// check line21 indicator (first user data must be line21 data in DVD Book)
if(!((m_UserData.Get(0) == 0x43) && (m_UserData.Get(1) == 0x43)))
{
//Not Line21 data
//DBG_BREAK();
//RETAILMSG(ZONE_ERROR,(TEXT("Not Line21 Data \r\n")));
ziva.USER_DATA_READ = write;
return;
}
// check top_field_flag_of_gop
// GOP�̓��̃t�B�[���h������킵�Ă���B
// �����𑗂�Ȃ��Ƃ��ׂĂ�\�����邱�Ƃ��ł��Ȃ��B
// if((data[4] & 0x80) == 0)
// {
// // data size error
// DBG_BREAK();
// DEBUGMSG(ZONE_TRACE,(TEXT("Bottom field data!!\r\n")));
// ziva.USER_DATA_READ = write;
// return;
// } else {
// ziva.USER_DATA_READ = write;
// return;
// }
DWORD number_of_data;
number_of_data = m_UserData.Get(4) & 0x3F;
// user_data_start_code -> number_of_displayed_field_gop = 5byte
if ((number_of_data * 3) + 5 > data_size)
{
// data size error
DBG_BREAK();
//DEBUGMSG(ZONE_ERROR,(TEXT("line21 data size error \r\n")));
return;
}
// �L���f�[�^�������O�o�b�t�@�ɓo�^
count = 0;
point = m_CCDataPoint;
m_CCRingBufferNumber = 0;
while(count<number_of_data)
{
if(m_UserData.Get(5+count*3) != 0xFF)
{
// line21_switch off
count++;
} else {
// RETAILMSG(1,(TEXT("%c%c"),(data[count*3+6] & 0x7f),(data[count*3+7] & 0x7f)));
m_CCData[m_CCDataPoint] = (DWORD)(m_UserData.Get(count*3+6)<<8)
| m_UserData.Get(count*3+7);
m_CCRingBufferNumber++;
count++;
m_CCDataPoint++;
if (m_CCDataPoint >= CC_DATA_SIZE)
{ m_CCDataPoint = 0; }
}
}
m_CCRingBufferStart = point;
NotifyEvent( &m_UserDataEventList, &m_UserData );
// RETAILMSG(1,(TEXT("\r\n")));
// DEBUGMSG(ZONE_TRACE,(TEXT("line21 data size 0x%x ring start 0x%x num0x%x \r\n"),
// m_CCDataNumber,
// m_CCRingBufferStart,m_CCRingBufferNumber));
// USER_DATA_READ��USER_DATA_WRITE�̃A�h���X���������݁AZiVA�Ƀf�[�^�̓]���I����
// �m�点��B
ziva.USER_DATA_READ = write;
return;
}
//---------------------------------------------------------------------------
// CMPEGBoardHAL::SendCCData
// m_CCDataNumber ���ꂩ�瑗��ׂ��f�[�^�̃T�C�Y
// by oka for Closed Caption
//---------------------------------------------------------------------------
inline void CMPEGBoardHAL::SendCCData( void )
{
// �Е��̃t�B�[���h�ł̂ݏ���������BEven�̂Ƃ���Odd�̃f�[�^�������̂����z
// �������A�t����Ȃ��Ƃ�����ƂłȂ��B�H�H�H
if( ziva.VIDEO_FIELD == 0 ) // check Top field?
{
// RETAILMSG(1,(TEXT("top field\r\n")));
// return;
} else {
return;
}
// �^�C�~���O�ɂ���Ă͐V�K�f�[�^�̓o�^�̂��Ƃɏ��������ق���������������Ȃ��B
if(m_CCnumber < m_CCDataNumber)
{
adv->SetClosedCaptionData( m_CCData[m_CCsend_point] );
m_CCsend_point++;
m_CCnumber++;
} else {
adv->SetClosedCaptionData( 0x00008080 );
}
// Ring�o�b�t�@�̐ݒ�
if (m_CCsend_point >= CC_DATA_SIZE)
m_CCsend_point = 0;
// ���̃o�b�t�@�̊J�n�ʒu���^���炽
if (m_CCRingBufferStart != 0xFFFFFFFF)
{
//�O�̃f�[�^�̓]�������ׂďI�����Ă�����
if (m_CCnumber == m_CCDataNumber)
{
ASSERT(m_CCsend_point == m_CCRingBufferStart);
m_CCsend_point = m_CCRingBufferStart;
m_CCDataNumber = m_CCRingBufferNumber;
}
else // �f�[�^�̓]�����ǂ����Ȃ������Ƃ��̏���
{
m_CCpending = m_CCDataNumber - m_CCnumber;
// ���ꂩ�瑗��ׂ��f�[�^�̐�
m_CCDataNumber = m_CCpending + m_CCRingBufferNumber;
// ����Ȃ��f�[�^���R�O������A���������ł��Ȃ��̂Ŏ̂Ă�B
if (m_CCpending > 30)
{
//RETAILMSG(ZONE_ERROR,(TEXT("pendig data is too large \r\n")));
m_CCpending = 0;
m_CCDataNumber = m_CCRingBufferNumber;
m_CCsend_point = m_CCRingBufferStart;
}
}
// if (m_CCpending > 0)
// {
// RETAILMSG(ZONE_TRACE,(TEXT("send_p %02x num %02x RingStart %02x RingNumber %02x "),
// m_CCsend_point,m_CCnumber, m_CCRingBufferStart,m_CCRingBufferNumber));
//
// RETAILMSG(ZONE_TRACE,(TEXT("pend %02x CCDataNumber %04x \r\n"),
// m_CCpending,m_CCDataNumber));
// }
m_CCRingBufferStart = 0xFFFFFFFF;
// �������f�[�^�̐��̏�����
m_CCnumber = 0;
} else {
//�]�����ǂ����Ȃ������Ƃ��ɂ���Ȃ��f�[�^���Ƃ�
while((m_CCpending > 0) && (m_CCData[m_CCsend_point] == 0x00008080))
{
m_CCsend_point++;
m_CCpending--;
m_CCnumber++;
if (m_CCsend_point >= CC_DATA_SIZE)
{ m_CCsend_point = 0;}
}
}
// if(m_CCnumber > m_CCDataNumber)
// {
// RETAILMSG(1,(TEXT("m_CCnumber > m_CCDataNumber \r\n")));
// DBG_BREAK();
// }
ASSERT(m_CCnumber <= m_CCDataNumber);
return;
}
//---------------------------------------------------------------------------
// CMPEGBoardHAL::SetEventIntMask
// mask �g�p����C�x���g�r�b�g�𗧂Ă��l
// by oka
//---------------------------------------------------------------------------
BOOL CMPEGBoardHAL::SetEventIntMask( DWORD mask )
{
// ZiVA use 0-23 bit
if ( (mask & 0xff000000) != 0)
return FALSE;
DWORD tmp_mask;
tmp_mask = mask;
for ( DWORD bit = 0; bit < 24 ; bit++ )
{
if( (tmp_mask & 0x00000001) != 0 )
{
m_MaskReference[bit]++;
}
tmp_mask = tmp_mask >> 1;
}
m_EventIntMask |= mask;
return TRUE;
}
//---------------------------------------------------------------------------
// CMPEGBoardHAL::UnsetEventIntMask
// mask �g�p�s�ɂ���C�x���g�r�b�g�𗧂Ă��l
// by oka
//---------------------------------------------------------------------------
BOOL CMPEGBoardHAL::UnsetEventIntMask( DWORD mask )
{
// ZiVA use 0-23 bit
if ( (mask & 0xff000000) != 0)
return FALSE;
DWORD tmp_mask = 0;
for ( DWORD bit = 0; bit < 24 ; bit++ )
{
if( (mask & 0x00000001) != 0 )
{
if ( m_MaskReference[bit] < 2 )
{
tmp_mask |= (0x1 << bit);
m_MaskReference[bit] = 0;
} else {
m_MaskReference[bit]--;
}
}
mask = (mask >> 1);
}
m_EventIntMask &= (DWORD)~(tmp_mask);
return TRUE;
}
//---------------------------------------------------------------------------
//
//---------------------------------------------------------------------------
//***************************************************************************
// End of Zivabrd.cpp
//***************************************************************************