DVD

开发平台：
Others

WMA.c：源码内容
							
/****************************************************************************************
 *  Copyright (c) 2000 ZORAN Corporation, All Rights Reserved
 *  THIS IS UNPUBLISHED PROPRIETARY SOURCE CODE OF ZORAN CORPORATION
 *
 *  File: $Workfile: WMA.c $             
 *
 * Description:
 * ============
 * WMA Clip implementation
 *
 * Log:
 * ====
 ****************************************************************************************
 * Updates:
 ****************************************************************************************
 * $Log: /I76/I76_Common/I76_Reference/Playcore/Nav_Clips/WMA.c $
 * 
 * 12    3/05/04 3:00p Terencet
 * correct can't get WMA stream information because wrong address
 * 
 * 11    2/13/04 7:05p Terencet
 * handle WMA unsupported sample/bit rate on CPU side
 * 
 * 10    1/20/04 12:30p Chaol
 * handle WMA unsupportted sample rate and bit rate on CPU side
 * 
 * 9     12/18/03 11:43a Leslie
 * Abort drive each time after retriveing  ASF info from WMA file
 * 
 * 8     11/27/03 13:27 Nmaurer
 * Use DEC_ReadCodeBufferFullness to get the BE buffers fullness
 * 
 * 7     11/15/03 7:11p Leslie
 * Replace old  Video API Low Level Files with new ones
 * 
 * 6     11/10/03 11:33a Leonh
 * Get Sampling rate for WMA
 * 
 * 5     03-03-04 11:34 Jerryc
 * jerry cai, merge new nav clips lib 
 * 
 * 3     03-01-10 12:21 Leslie
 * Add wide-character strings support
 * 
 * 2     03-01-09 12:30 Leslie
 * 
 * 1     10/30/02 18:06 Rond
 * 
 * 1     11/09/02 15:49 Atai
 * 
 * 2     22/08/02 18:18 Nirm
 * - First revision.
 * 
 * 1     16/08/02 14:52 Nirm
 ****************************************************************************************/
#include "Config.h"		// Global Configuration - do not remove!
#ifdef _DEBUG
#undef IFTRACE
#define IFTRACE if (gTraceNavigator)
#include "DebugDbgMain.h"
#endif
#include "Includemath-macro.h"
//#include "KernelEventDef.H"
#include "DecoderDecoder.h"
#include "DecoderDec_defs.h"
#include "Decoderlow_levelDEC_LL_Def.h"
#include "Drivedrv_api.h"
#include "Drivedrv_defs.h"
#include "LogoLogo.h"
#include "PlaycoreCoremainCoreGDef.h"
#include "PlaycoreAuxCacheAuxCache.h"
#include "PlaycoreFileSysFileSystem.h"
#include "PlaycoreNav_ClipsWMA_ASF.h"
#include "PlaycoreNav_ClipsWMA.h"
#include "PlaycoreNav_ClipsClip_Impl.h"
#include "PlaycoreNav_ClipsGenericClip.h"
#include "PlaycoreNav_ClipsNav_Clips.h"
#include "PlaycoreNav_ClipsPE_Clips.h"
//JerryCAI_0923_2003_A
extern DEC_DISC_TYPE gDiskType;
/////////////////////////////////////////////////////////////////////////////
// General WMA
/////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////
// Common Structures & Types
/////////////////////////////////////////////////////////////////////////////
// Globals and Singletons
#define g_ASFInfoCache gns.clips.globals.wmaGlobals.g_ASFInfoCache
/*
ADP didn't handle the unsupported sample rate and bit rate, in I54, it's handle by CPU
Currently, the WMA decoder supports the following sampling and bit rates:
1. Sampling rates: 32kHz, 44.1 kHz, and 48 kHz
2. Bit rates: 32 kbps or higher
*/
#ifdef CLIPS_WMA_UNSUPPORTRATE_HANDLE_BY_CPU
#define WMA_SUPPORTED_SAMPLINGRATE_MIN		32000UL
#define WMA_SUPPORTED_SAMPLINGRATE_MAX		48000UL
#define WMA_BITRATE_MARGIN				1000UL
#define WMA_SUPPORTED_BITRATE_MIN		(32000UL-WMA_BITRATE_MARGIN)
#define WMA_SUPPORTED_BITRATE_MAX		384000UL
#define bWMAUnsupportedRate gns.clips.globals.wmaGlobals.bWMAUnsupportedRate
#endif
#if (defined(CLIPS_ACQUIRE_EXTENDED_INFO) && defined(CLIPS_WMA_EXTRACT_CONTENT_DESC))
CONST GUID g_guidHeaderObj= HEADER_OBJECT_GUID;
CONST GUID g_guidPropertiesObj= PROPERTIES_OBJECT_GUID;
CONST GUID g_guidStreamPropertiesObj= STREAM_PROPERTIES_OBJECT_GUID;
CONST GUID g_guidAudioStreamPropertiesObj= AUDIO_STREAM_PROPERTIES_GUID;
CONST GUID g_guidContentDescriptionObj= CONTENT_DESCRIPTION_OBJECT_GUID;
#endif //(defined(CLIPS_ACQUIRE_EXTENDED_INFO) && defined(CLIPS_WMA_EXTRACT_CONTENT_DESC))
/////////////////////////////////////////////////////////////////////////////
// Private Services
/////////////////////////////////////////////////////////////////////////////
// _convertUnicodeToASCII()
//
// Description:	Converts a Unicode string into native ASCII.
//
// Input:	i_pszUnicode - A Unicode string to convert.
//			uSourceLength - The length, in Bytes, of the source Unicode string.
// Output:	o_pszTargetAscii - A target string, to hold the resulting ASCII
//							   representation.
// In/Out:	None
// Return:	None
//
// Remarks:	
//	1. A source Unicode string holds wide-characters, each 2-Bytes long.
//	   These are converted to the equivalent single-Byte ANSI characters, if
//	   such a conversion is possible.
//	2. The size of the target ASCII string must be at least half that of the
//	   source Unicode string in order to accomodate the full conversion.
static void _convertUnicodeToASCII(const WCHAR *i_pszUnicode, LPSTR o_pszTargetAscii,
								   UINT8 uSourceLength)
{
	UINT8 uPos;
	UINT8 uEffectiveLength= (MIN(uSourceLength, (2*WMA_TEXT_LENGTH)) / 2);
	dbg_printf(("_convertUnicodeToASCII() calling.n"));
	for (uPos=0; uPos < uEffectiveLength; uPos++) {
		char wcCharHigh= ((i_pszUnicode[uPos] >> 8) & 0xFF);
		char wcCharLow= (i_pszUnicode[uPos] & 0xFF);
		char cAsciiEquivalent;
		if (wcCharHigh >= 0x03)
			cAsciiEquivalent= '?';	// No ASCII equivalent
		else
			cAsciiEquivalent= wcCharLow;
		o_pszTargetAscii[uPos]= cAsciiEquivalent;
	}
	// NULL-terminate the constructed string
	o_pszTargetAscii[uPos]= 0;
	return;
}
/////////////////////////////////////////////////////////////////////////////
// _acquireASFInfo()
//
// Description:	Acquires the ASF-Information for a Clip
//
// Input:	dwClipStartAddr - The start-address of the Clip
// Output:	o_pInfo - Points to an ASFInfo structure, to receive the result
// In/Out:	None
// Return:	TRUE if the ASF-Information was extracted successfully;
//			FALSE otherwise.
//
// Remarks:	
//	ASF Information is extracted from the Header and Properties Objects of
//	the stream.
static BOOL _acquireASFInfo(DWORD dwClipStartAddr, ASFInfo *o_pInfo)
{
	DWORD cbOffset;
	DWORD dwHeadersCnt;
	DWORD cbObjectSize;
	BYTE  aObjectBuff[sizeof(HeaderObject)];
	// Read the Header-Object's base, and verify that this is indeed a Header Object
	if ( !AuxCache_GetBytes(dwClipStartAddr, 0, sizeof(aObjectBuff), aObjectBuff)
#if (defined(CLIPS_ACQUIRE_EXTENDED_INFO) && defined(CLIPS_WMA_EXTRACT_CONTENT_DESC))
		||
		 (0 != memcmp(aObjectBuff, &g_guidHeaderObj, sizeof(GUID))) 
#endif
		 )
	{
		dbg_printf(("WARNING: _acquireASFInfo() Failed [1]n"));
		return FALSE;
	}
	// Extract the Headers-Count
	dwHeadersCnt= ((HeaderObject*)aObjectBuff)->dwHeadersCnt;
	// Extract the Total Size of the Header-Object
	// NOTE: The following line assumes that the Object's size is a 32-bit
	//       number (the high 32-bits are ignored).
	o_pInfo->cbHeaderSize= LE_QWORD_LOW(((struct ObjectBase*)aObjectBuff)->cbSize);
	// Scan the ASF Headers, looking for a Properties Object
	cbOffset= sizeof(HeaderObject);
	while (dwHeadersCnt > 0) {
		// Read the next Object
		if (!AuxCache_GetBytes(dwClipStartAddr, cbOffset, sizeof(ContentDescriptionObject), 
						  aObjectBuff)) 
		{
			dbg_printf(("WARNING: _acquireASFInfo() Failed [2]n"));
			break;
		}
		// Extract the Object's Size
		// NOTE: The following line assumes that the Object's size is a 32-bit
		//       number (the high 32-bits are ignored).
		cbObjectSize= LE_QWORD_LOW(((struct ObjectBase*)aObjectBuff)->cbSize);
#if (defined(CLIPS_ACQUIRE_EXTENDED_INFO) && defined(CLIPS_WMA_EXTRACT_CONTENT_DESC))
		// Check if this is a Properties Object
		if (0 == memcmp(aObjectBuff, &g_guidPropertiesObj, sizeof(GUID))) {
			break;
		}
#endif
		// This isn't the required Object - continue to the next one
		dwHeadersCnt--;
		// NOTE: The following line assumes that the Object's length is a 32-bit
		//       number (the high 32-bits are ignored).
		cbOffset += cbObjectSize;
	}
	// Check if the required Object was found
	if (0 == dwHeadersCnt)
		return FALSE;
	// Now extract the Maximum size of Interleaved Packets
	cbOffset += PROPERTIES_OBJECT_MAX_PKT_SIZE_OFFSET;
	if (!AuxCache_GetBytes(dwClipStartAddr, cbOffset, sizeof(DWORD), 
					  (BYTE*)&o_pInfo->cbPacketSize)) 
	{
		dbg_printf(("WARNING: _acquireASFInfo() Failed [3]n"));
		
		return FALSE;
	}
	return TRUE;
}
/////////////////////////////////////////////////////////////////////////////
// Public Services
#pragma argsused
void WMA_setPresentationTime(UINT8 uPresentationTime)
{
	dbg_printf(("WARNING: WMA_setPresentationTime() Failed: WMA Clips cannot have a presentation time.n"));
}
#if (defined(CLIPS_ACQUIRE_EXTENDED_INFO) && defined(CLIPS_WMA_EXTRACT_CONTENT_DESC))
BOOL WMA_GetWMAInfo(DWORD dwClipStartAddr,
							   WORD i_pExtInfo_sc_handle)
{
	WORD *pCurrTextLen;
	DWORD cbOffset;
	DWORD dwHeadersCnt;
	DWORD cbObjectSize;
	BYTE  aObjectBuff[sizeof(ContentDescriptionObject)];
	BYTE  ucContentCnt;
	WCHAR szUnicodeText[WMA_TEXT_LENGTH];
	LPWSTR pszDestTextField;
	//Angie_0810_2004:Move the MP3 and WMA extend info from gns to SCPAD for I86 memory reducing.
	WMA_ExtendInfo o_pInfoDesc;
	
	//Stivenz_1131_2004: fix WMA extendinfo display error.
	memset(&o_pInfoDesc,0,sizeof(WMA_ExtendInfo));
	
	// Read the Header-Object's base, and verify that this is indeed a Header Object
	if ( !AuxCache_GetBytes(dwClipStartAddr, 0, sizeof(aObjectBuff), aObjectBuff) 
#if (defined(CLIPS_ACQUIRE_EXTENDED_INFO) && defined(CLIPS_WMA_EXTRACT_CONTENT_DESC))
		||
		 (0 != memcmp(aObjectBuff, &g_guidHeaderObj, sizeof(GUID))) 
#endif
		 )
	{
		dbg_printf(("WARNING: WMA_GetWMAInfo() Failed [1]n"));
		return FALSE;
	}
	// Extract the Headers-Count
	dwHeadersCnt= ((HeaderObject*)aObjectBuff)->dwHeadersCnt;
	// Scan the ASF Headers, looking for a Content-Description Object
	cbOffset= sizeof(HeaderObject);
	while (dwHeadersCnt > 0) {
		// Read the next Object
		if (!AuxCache_GetBytes(dwClipStartAddr, cbOffset, sizeof(ContentDescriptionObject), 
						  aObjectBuff)) 
		{
			dbg_printf(("WARNING: WMA_GetWMAInfo() Failed [2]n"));
			break;
		}
		// Extract the Object's Size
		// NOTE: The following line assumes that the Object's size is a 32-bit number (the high 32-bits are ignored).
		cbObjectSize= LE_QWORD_LOW(((struct ObjectBase*)aObjectBuff)->cbSize);
		
		// Check if this is a audio stream properties Object
		if (0 == memcmp(aObjectBuff, &g_guidStreamPropertiesObj, GUID_SIZE))
		{
			DWORD streamTypeIDOffset;
			streamTypeIDOffset = cbOffset+OBJECT_HEADER_SIZE;
			// get the stream type from steam properties object
			if (AuxCache_GetBytes(dwClipStartAddr, streamTypeIDOffset, GUID_SIZE, aObjectBuff)) 
			{
				// Check if this is a ASF_Audio_Media
				if (0 == memcmp(aObjectBuff, &g_guidAudioStreamPropertiesObj, GUID_SIZE) )
				{
					DWORD TypeSpecificOffset;
					TypeSpecificOffset = cbOffset+TYPE_SPECIFIC_DATA_ADD;
					if (AuxCache_GetBytes(dwClipStartAddr, TypeSpecificOffset, sizeof(WAVEFORMATEX), aObjectBuff)) 
					{
						memcpy(&(gns.clips.iClipSamplingRate), (unsigned char *) (&aObjectBuff [4]), sizeof(gns.clips.iClipSamplingRate));
#ifdef CLIPS_WMA_UNSUPPORTRATE_HANDLE_BY_CPU
						{
							UINT32 ulAverageBitRate;
							memcpy(&ulAverageBitRate, (unsigned char *) (&aObjectBuff [8]), sizeof(ulAverageBitRate));
							ulAverageBitRate = 8*ulAverageBitRate;
							if( (gns.clips.iClipSamplingRate < WMA_SUPPORTED_SAMPLINGRATE_MIN)||
								(ulAverageBitRate < WMA_SUPPORTED_BITRATE_MIN) )
							{
								bWMAUnsupportedRate = TRUE;
								if(gns.clips.iClipSamplingRate < WMA_SUPPORTED_SAMPLINGRATE_MIN)
									tr_printf(("nWMA unsupported sampling rate= %8ldn", gns.clips.iClipSamplingRate));
								if(ulAverageBitRate < WMA_SUPPORTED_BITRATE_MIN)
									tr_printf(("nWMA unsupported bit rate= %8ldn", ulAverageBitRate));
							}
							else
								bWMAUnsupportedRate = FALSE;								
						}
#endif						
					}
					else
					{
						dbg_printf(("WARNING: WMA get Audio Stream Type Specific Data Failedn"));
					}	
				}
				else
				{
					dbg_printf(("WARNING: WMA is not a standard ASF audion"));
				}	
			}
			else
			{
				dbg_printf(("WARNING: WMA get Audio Stream Type ID Failedn"));
			}	
		}
		// Check if this is a Contents-Description Object
		else if (0 == memcmp(aObjectBuff, &g_guidContentDescriptionObj, sizeof(GUID)))
		{
			DWORD ContentDescriptionOffset;
			ContentDescriptionOffset = cbOffset+sizeof(ContentDescriptionObject);
			
			// Extract the relevant fields of the Content-Description Object
			pCurrTextLen= (WORD*)&aObjectBuff[sizeof(struct ObjectBase)];
			pszDestTextField= o_pInfoDesc.szTitle;
			// Collect the text: Title/Author/Copyright/Description
			for (ucContentCnt=0; ucContentCnt < 4; ucContentCnt++) {
				// Copy the current field to the Unicode-buffer
				if (!AuxCache_GetBytes(dwClipStartAddr, ContentDescriptionOffset, sizeof(szUnicodeText), (BYTE*)szUnicodeText)) {
					dbg_printf(("WARNING: WMA_GetWMAInfo() Failed [3]n"));
					continue;
				}
				// NOTE: The text is given in Little-Endian order, since it originates from a PC
				if (*pCurrTextLen) {
#ifdef MOTOROLA
					swab((LPSTR)szUnicodeText, (LPSTR)pszDestTextField, sizeof(szUnicodeText));
#else
					memcpy(pszDestTextField, szUnicodeText, sizeof(szUnicodeText));
#endif //MOTOROLA
					pszDestTextField[WMA_TEXT_LENGTH-1]= 0;
				}
				// Continue to the next field
				ContentDescriptionOffset += *pCurrTextLen;
				pCurrTextLen++;
				pszDestTextField += (WMA_TEXT_LENGTH+1);
			}
		}
		// continue to the next object
		dwHeadersCnt--;
		// NOTE: The following line assumes that the Object's length is a 32-bit number (the high 32-bits are ignored).
		cbOffset += cbObjectSize;
	}
	sc_SetBytes(i_pExtInfo_sc_handle,0,sizeof(WMA_ExtendInfo),(BYTE *)&o_pInfoDesc);
	return TRUE;
}
#endif //(defined(CLIPS_ACQUIRE_EXTENDED_INFO) && defined(CLIPS_WMA_EXTRACT_CONTENT_DESC))
/////////////////////////////////////////////////////////////////////////////
// WMA Clip
/////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////
// Forward Declarations of Virtual Methods
BOOL WMAClip_getExtendedInfo(const struct Clip_TAG *i_pThis, 
							 WORD i_pExtInfo_sc_handle);
BOOL WMAClip_play(Clip *i_pThis, const ClipMarker *i_pResumeMarker,
				  BOOL bCacheOnly);
enClipStatus WMAClip_getStatus(const Clip *i_pThis);
void WMAClip_refresh(Clip *i_pThis);
/////////////////////////////////////////////////////////////////////////////
// Const Factory
// Valid Extenions List
BEGIN_CLIP_VALID_EXTENSIONS_MAP(WMA)
	CLIP_VALID_EXTENSIONS_ENTRY(L"WMA")
END_CLIP_VALID_EXTENSIONS_MAP()
// Constant Attributes
DECLARE_CLIP_CONST_ATTR(WMA, 
						DECLARE_CLIP_VTABLE(WMAClip_getExtendedInfo,
											WMAClip_play,
											GenericClip_pause,
											WMAClip_getStatus,
											GenericClip_abort,
											GenericClip_recordMarker,
											WMAClip_refresh,
											GenericClip_getTime,
											GenericClip_digest,
											GenericClip_scan
											),
						eClipType_WMA,
						DEC_ASID_WMA, 0xFF, DEC_DISC_TYPE_WMA,
						eCA_Markable,
						NULL
						)
/////////////////////////////////////////////////////////////////////////////
// Public Services
BOOL WMAClip_isKindOf(LPCWSTR i_pszFilename)
{
	return GenericClip_isKindOf(i_pszFilename, CLIP_VALID_EXTENSIONS(WMA));
}
void WMAClip_construct(Clip *o_pThis, const FindData *i_pFileInfo)
{
	GenericClip_construct(o_pThis, i_pFileInfo);
	o_pThis->m_pConstAttr= &CLIP_CONST_ATTR(WMA);
}
/////////////////////////////////////////////////////////////////////////////
// Virtual Methods
BOOL WMAClip_getExtendedInfo(const struct Clip_TAG *i_pThis, 
							 WORD i_pExtInfo_sc_handle)
{
	BOOL bSuccess= FALSE;
	dbg_printf(("WMAClip_getExtendedInfo()n"));
#ifdef CLIPS_WMA_EXTRACT_CONTENT_DESC
	ASSERT(NULL != i_pExtInfo_sc_handle)
	bSuccess= WMA_GetWMAInfo(i_pThis->m_cfiInfo.dwFileLocation, 
										i_pExtInfo_sc_handle);
#endif //CLIPS_WMA_EXTRACT_CONTENT_DESC
	return bSuccess;
}
BOOL WMAClip_play(Clip *i_pThis, const ClipMarker *i_pResumeMarker,
				  BOOL bCacheOnly)
{
	BOOL bAudioPacketPosAvailable= FALSE;
	ASFInfo *pASFInfo;
	dbg_printf(("WMAClip_play()n"));
   gDiskType = (i_pThis->m_pConstAttr)->m_eBitstreamType; //gDiskType must be set before calling DEC_prepare_to_decode().
	// Acquire this Clip's ASF-Info from the Cache
	pASFInfo= &g_ASFInfoCache.asfInfo;
	// Check if the ASF-Info should be acquired
	if ((NULL == i_pResumeMarker) && 
		(g_ASFInfoCache.dwID != (i_pThis->m_cfiInfo).dwFileLocation))
	{
		if (_acquireASFInfo((i_pThis->m_cfiInfo).dwFileLocation, pASFInfo)) 
		{
			g_ASFInfoCache.dwID= (i_pThis->m_cfiInfo).dwFileLocation;
		}
		else
		{
			tr_printf(("nWarning: Corrupted file!n"));
			// Stop the Clock
			PE_Clips_EnableClock(FALSE, TRUE, 0);
			DEC_CacheInit();
			
			//abort playback if ASF info unavailable
			GenericClip_abort(i_pThis,TRUE);
//			bWMAUnsupportedRate = TRUE;
			return TRUE;
		}
	}
	drv_abort_play();// abort drive after reading ASF-Info from Drive
	
	// Set the Audio-Packet Offset to Zero by default
#ifndef D_ENABLE_DIVX_WMA_SUPPORT
	DEC_WMA_SetAudioPacketHeaderOffset(0);
#endif
	// In case of playback-resumption, calculate the position of the next 
	// Audio-Packet Header.
	if ((NULL != i_pResumeMarker) && 
		(g_ASFInfoCache.dwID == (i_pThis->m_cfiInfo).dwFileLocation)) 
	{
		UINT32 cbFileOffset;
		DWORD  cbAudioPacketOffset;
		cbFileOffset= (LOGICAL_BLOCK_SIZE * 
					   (i_pResumeMarker->dwAddress - (i_pThis->m_cfiInfo).dwFileLocation));
		cbAudioPacketOffset= 
			( pASFInfo->cbPacketSize - 
			  ((cbFileOffset - pASFInfo->cbHeaderSize - 
				sizeof(DataSectionIntroductionObject)) % pASFInfo->cbPacketSize) );
		// Inform the Decoder about the offset
#ifndef D_ENABLE_DIVX_WMA_SUPPORT
		DEC_WMA_SetAudioPacketHeaderOffset(cbAudioPacketOffset);
#endif
		bAudioPacketPosAvailable= TRUE;
	}
	// Override the Resume-Marker if the Audio-Packet position isn't available
	return GenericClip_play(i_pThis, 
							(bAudioPacketPosAvailable ? i_pResumeMarker : NULL), 
							bCacheOnly);
}
#pragma argsused
enClipStatus WMAClip_getStatus(const Clip *i_pThis)
{
#ifdef CLIPS_WMA_UNSUPPORTRATE_HANDLE_BY_CPU
	if( bWMAUnsupportedRate )
	{
		bWMAUnsupportedRate = FALSE;
		return eCS_Error_UnsupportedFormat;
	}
#endif
	if (drv_is_play_done() && DEC_IsPlaybackFinished(FALSE))
		return eCS_Finished;
#ifdef CLIPS_WMA_READ_ADP_STATUS
{
	UINT8 uStatus;
	uStatus= DEC_WMA_getStatus();
	switch (uStatus)
	{
	case WMA_STAT_ERR_UNSUPPORTED:
		tr_printf(("WMAClip_getStatus : WMA_STAT_ERR_UNSUPPORTEDn"));
		return eCS_Error_UnsupportedFormat;
	case WMA_STAT_ERR_FATAL:
		tr_printf(("WMAClip_getStatus : WMA_STAT_ERR_FATALn"));	
		return eCS_Error_Decoding;
	}
}
#endif //CLIPS_WMA_READ_ADP_STATUS
	return eCS_Busy;
}
#pragma argsused
void WMAClip_refresh(Clip *i_pThis)
{
	if (PST_PLAY == gcs.pstate) {
		BOOL bEnableClock= (0 != DEC_ReadCodeBufferFullness(DEC_AUDIO_CODE_BUFFER, DEC_FULLNESS_IN_BYTES));
		PE_Clips_EnableClock(bEnableClock, FALSE, 0);
	}
}

						