DVD

开发平台：

Others

MP4.c：源码内容

/****************************************************************************************
* THIS IS UNPUBLISHED PROPRIETARY SOURCE CODE OF ZORAN CORPORATION
*
* File: $Workfile: MP4.c $
*
* Description:
* ============
* MP4 Implement
*
* Log:
* ====
* $Revision: #36 $
* $Change: 29878 $
* Last Modified by $Author: robin.jiang $ at $DateTime: 2004/10/29 18:04:12 $
****************************************************************************************
* Updates:
****************************************************************************************
* $Log: /I76/I76_Common/I76_Reference/Playcore/Nav_Clips/MP4.c $
*
* 1 8/2/2004 RobinJ
* Created
*
****************************************************************************************/
#include "Config.h" // Global Configuration - do not remove!
#ifdef IS_MP4_CAPABLE
#ifdef _DEBUG
#undef IFTRACE
#define IFTRACE if (gTraceNavigator)
#include "Debugdbgmain.h"
#endif
#include "Includesysdefs.h"
#include "KernelEventDef.H"
#include "PlaycoreNav_ClipsMP4.h"
#include "PlaycoreNav_ClipsMpeg4ClipsCommon.h"
#include "PlaycoreNav_ClipsClip_Impl.h"
#include "PlaycoreNav_ClipsGenericClip.h"
#include "PlaycoreNav_ClipsPE_Clips.h"
#include "PlaycoreCoremainCoreDefs.h"
#include "PlaycoreCoremainCoreGDef.h"
#include "LogoLogo.h"
#include "PlaycoreAuxCacheAuxCache.h"
#include "Decoderlow_levelDEC_LL_Reg.h"
#include "PlaycorePlayModePlayMode.h"
#include "Drivedrv_api.h"
#include "DecoderDecoder.h"
#ifdef USE_AUX_SUBTITLES
#include "PlaycoreNav_ClipsAuxSubtitles.h"
#endif
#ifdef SUPPORT_FLASH_CARD
#include "drivefe_manager.h"
#include "mediacardsincluderegister.h"
#endif
#ifdef _DEBUG
#include "CPUTimefunc.h"
#endif
/////////////////////////////////////////////////////////////////////////////
// Globals and Singletions
/////////////////////////////////////////////////////////////////////////////
// just for debug
//#define PRINTF_MP4_SMAPLE_TABLE
//#define MAX_PRINTF_TABLE_SIZE (MAX_SAMPLE_TABLE_BUFFER_SIZE*1)
//#define PRINTF_MP4_CHUNK_SIZE
//#define MAX_PRINTF_CHUNK_NUM 100
//#ifdef PRINTF_MP4_CHUNK_SIZE
//static UINT32 MAX_PRINTF_CHUNK_NUM = 3000;
//#endif
//#define PRINTF_MP4_TRANSFER_CHUNK_SIZE
//#ifdef PRINTF_MP4_TRANSFER_CHUNK_SIZE
//static DWORD dwTransferChunkOffset = 0;
//#endif
#define MP4_PACK_TRANSFER_CHUNK_SIZE 1
#ifdef SDRAM_2X16MBITS
#define MP4_PACK_CHUNK_NUMBER_THRESHOLD 120000UL
#else
#define MP4_PACK_CHUNK_NUMBER_THRESHOLD 350000UL
#endif
#ifdef SDRAM_2X16MBITS
#define FRAME_BUFFER_R1_ADDR 0x0B3800UL
#else
#define FRAME_BUFFER_R1_ADDR 0x200000UL
#endif
#define MP4_PACK_STSC 1
#define MP4_PACK_STCO_BUFF_SIZE 10
#define MP4_PACK_STCO_BUFF_SIZE_IN_WORD 5
#define MP4_STORE_SAMPLETABLE_AFTER 1
static BOOL bMP4NeedPack = TRUE; // if true, max chunk size is 0xFFFF
static DWORD dwMP4MaxStoreChunkSize = 0xFFFF00UL;
static UINT8 uiMP4ReservedNum = 0;
static BOOL bMP4UnSupportProfile;
// <<< Stivenz_0223_2005: If current chapter is unsupported then goto next.
#ifdef D_MP4_SKIP_UNSUPPORTED_CHAPTER
BOOL bMP4DRMDisable = FALSE;
#else
static BOOL bMP4DRMDisable;
#endif
#ifdef NO_AUTO_PLAY_FOR_CLIPS
extern BOOL g_patch_4_auto_play;
#endif
static CONST UINT32 SAMPLE_RATE_TABLE[16] = {96000UL,88200UL,64000UL,48000UL,44100UL,32000UL,
24000UL,22050UL,16000UL,12000UL,11025UL,8000UL,
7350UL,0UL,0UL,0UL};
#define mp4STSCOffsetInFile mp4StreamSampleTableAddrEX.mp4StreamSampleTableAddr.dwSTSCOffsetInFile
#define mp4STSCStartAddr mp4StreamSampleTableAddrEX.mp4StreamSampleTableAddr.dwSTSCStartAddr
#define mp4STSCEntryCount mp4StreamSampleTableAddrEX.mp4StreamSampleTableAddr.dwSTSCEntryCount
#define mp4STCOOffsetInFile mp4StreamSampleTableAddrEX.mp4StreamSampleTableAddr.dwSTCOOffsetInFile
#define mp4STCOStartAddr mp4StreamSampleTableAddrEX.mp4StreamSampleTableAddr.dwSTCOStartAddr
#define mp4STCOEntryCount mp4StreamSampleTableAddrEX.mp4StreamSampleTableAddr.dwSTCOEntryCount
#define mp4STSSOffsetInFile mp4StreamSampleTableAddrEX.mp4StreamSampleTableAddr.dwSTSSOffsetInFile
#define mp4STSSStartAdd mp4StreamSampleTableAddrEX.mp4StreamSampleTableAddr.dwSTSSStartAddr
#define mp4STSSEntryCount mp4StreamSampleTableAddrEX.mp4StreamSampleTableAddr.dwSTSSEntryCount
#define mp4STTSOffsetInFile mp4StreamSampleTableAddrEX.mp4StreamSampleTableAddr.dwSTTSOffsetInFile
#define mp4STTSStartAddr mp4StreamSampleTableAddrEX.mp4StreamSampleTableAddr.dwSTTSStartAddr
#define mp4STTSEntryCount mp4StreamSampleTableAddrEX.mp4StreamSampleTableAddr.dwSTTSEntryCount
#define mp4CompactSampeSize mp4StreamSampleTableAddrEX.mp4StreamSampleTableAddr.bCompactSampeSize
#define mp4STSZOffsetInFile mp4StreamSampleTableAddrEX.mp4StreamSampleTableAddr.dwSTSZOffsetInFile
#define mp4STSZSampleSize mp4StreamSampleTableAddrEX.mp4StreamSampleTableAddr.dwSTSZSampleSize
#define mp4STSZEntryCount mp4StreamSampleTableAddrEX.mp4StreamSampleTableAddr.dwSTSZEntryCount
#define mp4ChunkSizeStartAddr mp4StreamSampleTableAddrEX.mp4StreamSampleTableAddr.dwChunkSizeStartAddr // not used
#define mp4SyncEntryStartAddr mp4StreamSampleTableAddrEX.mp4StreamSampleTableAddr.dwSyncEntryStartAddr
#define mp4PackSTSC mp4StreamSampleTableAddrEX.mp4StreamSampleTableAddr.bPackSTSC
#define mp4PackSTCO mp4StreamSampleTableAddrEX.mp4StreamSampleTableAddr.bPackSTCO
#define mp4PackSTSZ mp4StreamSampleTableAddrEX.mp4StreamSampleTableAddr.bPackSTSZ
#define mp4CO64 mp4StreamSampleTableAddrEX.mp4StreamSampleTableAddr.bCO64
#define SIZE_OF_MP4StreamSampleTableAddrEX (sizeof(MP4StreamSampleTableAddrEX))
#define SIZE_OF_MP4StreamSampleTableAddrEX_IN_DWORD ((sizeof(MP4StreamSampleTableAddrEX) + 3) >>2)
#define MP4_AUDIO_SYNC_ENTRY_SIZE (sizeof(MP4AudioSyncEntry)/2)
#define MP4_VIDEO_SYNC_ENTRY_SIZE (sizeof(MP4VideoSyncEntry)/2)
#define MP4_AUDIO_SYNC_ENTRY_BUFF_SIZE (MP4_SYNC_ENTRY_BUFF_SIZE*MP4_AUDIO_SYNC_ENTRY_SIZE)
#define MP4_VIDEO_SYNC_ENTRY_BUFF_SIZE (MP4_SYNC_ENTRY_BUFF_SIZE*MP4_VIDEO_SYNC_ENTRY_SIZE)
#define MP4_SUBTITLE_SMAPLE_ENTRY_SIZE (sizeof(MP4SubtitleSampleEntry)/2)
#define MP4_SUBTITLE_SMAPLE_ENTRY_BUFF_SIZE (MP4_SUBTITLE_SAMPLE_ENTRY_BUFF_SIZE * MP4_SUBTITLE_SMAPLE_ENTRY_SIZE)
#define MP4_CALC_ENTRY_ADDRESS(address,size,index) (address - (index * size) - size)
#define MP4_CHUNK_SIZE_ENTRY_SIZE (sizeof(DWORD) / 2)
#define MP4_CHUNK_SIZE_ENTRY_BUFF_SIZE (MP4_CHUNK_SIZE_TABLE_BUFF_SIZE * MP4_CHUNK_SIZE_ENTRY_SIZE)
#define MP4_PACK_CHUNK_SIZE_ENTRY_BUFF_SIZE (MP4_PACK_CHUNK_SIZE_TABLE_BUFF_SIZE * MP4_CHUNK_SIZE_ENTRY_SIZE)
#define MP4_CHUNK_SIZE_TABLE_BUFF_SIZE2 64
#define MP4_PACK_CHUNK_SIZE_TABLE_BUFF_SIZE2 40
#define MP4_CHUNK_SIZE_ENTRY_BUFF_SIZE2 (MP4_CHUNK_SIZE_TABLE_BUFF_SIZE2 * MP4_CHUNK_SIZE_ENTRY_SIZE)
#define MP4_PACK_CHUNK_SIZE_ENTRY_BUFF_SIZE2 (MP4_PACK_CHUNK_SIZE_TABLE_BUFF_SIZE2 * MP4_CHUNK_SIZE_ENTRY_SIZE)
extern CURRENT_STATES gcst; /* Global current status */
extern BOOL change_pallet;
extern void DEC_SetMPP(BOOL enable);
extern void DEC_MP4_ChunkSizeFifoInit();
/////////////////////////////////////////////////////////////////////////////
static UINT32 _toBe32(BYTE *pBuff);
static UINT16 _toBe16(BYTE *pBuff);
#ifdef D_ENABLE_AAC_SUPPORT
static UINT32 getbits(UINT8 *buffer,UINT8 *CurrentPtr,UINT32 *cword,UINT8 *nbits,UINT8 n, UINT16 length);
static BOOL _mp4ReadAudioSpecificConfig(BYTE *AudioSpecificConfig, UINT16 length);
#endif
static BOOL _mp4ReadSubPictureConfig(BYTE *SubPictureConfig, UINT16 length);
static BOOL _mp4GetNextBox(DWORD dwClipStartAddr, DWORD* dwOffset, MP4Box* pMP4Box);
static int _mp4ReadDescr(DWORD dwStartAddr, DWORD *dwOffset, int *tag);
static BOOL _mp4StoreSampleTable(DWORD dwStartAddr, DWORD dwOffset, DWORD dwSampleTableSize, DWORD dwSampleTableAddr, BOOL b64Bits);
static BOOL _mp4ReadBox_ESDS(DWORD dwStartAddr, DWORD dwOffset, MP4_CODEC_TYPE trackCodecType, int *len);
static BOOL _mp4StreamsInfoProcessing(DWORD dwStartAddr, DWORD dwStartOffset, DWORD dwSize);
static BOOL _mp4InfoProcessing(DWORD dwClipStartAddr, ULONG cbFileSize);
static BOOL _mp4StreamSampleTableProcessing(DWORD dwStartAddr, WORD wSampleTableAddrEXAddr, DWORD *dwChunkSizeAddr, DWORD *dwSyncSampleAddr,
MP4_CODEC_TYPE codecType, DWORD dwMP4VideoSTSSStartAdd);
static BOOL _mp4SampleTableProcessing(DWORD dwStartAddr);
static void _mp4SetFirstSkipBytes(BOOL bScan);
static void _mp4TransferChunkSize(/*BOOL bFirst,*/ BOOL bWait);
static BOOL _mp4ChunkSizeProcessing(void);
static BOOL _mp4GetAdjacentIFrames(WORD wTime, DWORD *dwVideoSyncSampleNum, DWORD *dwSyncSampleOffset);
static void _mp4PrePlayProcessing(DWORD dwSamplingRate, UINT8 uiAudioSid,
UINT8 uiAudioSIDDecoder, UINT8 uiVideoSid, BOOL bClipStart, BOOL bScan);
static void _mp4InitTransferChunkSize(BOOL bScan, DWORD dwVideoSampleSize );
#ifdef MP4_TANSFER_CHUNKSIZE_BY_FIFO
static void _mp4TransferChunkSizeByFifo(void);
#endif
static BOOL _mp4Scan(INT8 iIndexIncrement, BOOL bContinue);
static void _mp4ClearAPPBuffer(void);
static void _mp4ChapterRefresh(void);
static BOOL _mp4DetectBVOP(void);
// Forward Declarations of Virtual Methods
BOOL MP4Clip_getExtendedInfo(const struct Clip_TAG *i_pThis, void *o_pExtInfoContainer);
BOOL MP4Clip_play(Clip *i_pThis, const ClipMarker *i_pResumeMarker, BOOL bCacheOnly);
void MP4Clip_pause(Clip *i_pThis, BOOL bEnable);
void MP4Clip_refresh(Clip *i_pThis);
UINT16 MP4Clip_getTime(const Clip *i_pThis);
enClipStatus MP4Clip_getStatus(const Clip *i_pThis);
void MP4Clip_scan(Clip *i_pThis, int iScanSpeed);
void MP4Clip_recordMarker(const Clip *i_pThis, ClipMarker *o_pMarker);
void MP4Clip_abort(Clip *i_pThis, BOOL bMaintainStandby);
void _mp4SubPictureArrived();
#ifdef MP4_TANSFER_CHUNKSIZE_BY_FIFO
extern void DEC_MP4_ChunkSizeFifoInit(void);
extern void DEC_MP4_SetFlashCardNotNeedCheck(void);
#endif
extern void mp4InitSubtitles(void);
/////////////////////////////////////////////////////////////////////////////
// Const Factory
/* Valid Extenions List */
BEGIN_CLIP_VALID_EXTENSIONS_MAP(MP4)
CLIP_VALID_EXTENSIONS_ENTRY(L"MP4")
CLIP_VALID_EXTENSIONS_ENTRY(L"M4A")
// CLIP_VALID_EXTENSIONS_ENTRY(L"MP4V") // Robin_TBD
// CLIP_VALID_EXTENSIONS_ENTRY(L"MP4A") // Robin_TBD
// CLIP_VALID_EXTENSIONS_ENTRY(L"3GP") // Robin_TBD
// CLIP_VALID_EXTENSIONS_ENTRY(L"MOV") // Robin_TBD
END_CLIP_VALID_EXTENSIONS_MAP()
/* Constant Attributes */
DECLARE_CLIP_CONST_ATTR(MP4,
DECLARE_CLIP_VTABLE(MP4Clip_getExtendedInfo,
MP4Clip_play,
MP4Clip_pause,
MP4Clip_getStatus,
MP4Clip_abort,
MP4Clip_recordMarker,
MP4Clip_refresh,
MP4Clip_getTime,
GenericClip_digest,
MP4Clip_scan
),
eClipType_MP4,
0xFF, 0xE0, DEC_DISC_TYPE_MP4, //FW0408_2005C Set 0xE0 as video SID
(eCA_Scanable | eCA_Zoomable | eCA_Slowable | eCA_Markable/* | eCA_Digestable*/),
NULL
)
/////////////////////////////////////////////////////////////////////////////
// Private Services
///////////////////////////////////////////////////////////////////////////
static UINT32 _toBe32(BYTE *pBuff)
{
#if 1
UINT32 ulResult;
BYTE *pResult = (BYTE*)&ulResult;
UINT16 uiInputIndex;
UINT16 uiOutputIndex = 3;
for (uiInputIndex=0; uiInputIndex<4; uiInputIndex++)
{
pResult[uiOutputIndex] = pBuff[uiInputIndex];
uiOutputIndex--;
}
return ulResult;
#else
return (((UINT32)pBuff[0] << 24) | ((UINT32)pBuff[1] << 16) | ((UINT32)pBuff[2] << 8) | ((UINT32)pBuff[3]));
#endif
}
static UINT16 _toBe16(BYTE *pBuff)
{
return (((UINT16)pBuff[0] << 8) | ((UINT16)pBuff[1]));
}
#ifdef D_ENABLE_AAC_SUPPORT
static UINT32 getbits(UINT8 *buffer,UINT8 *CurrentPtr,UINT32 *cword,UINT8 *nbits,UINT8 n, UINT16 length)
{
if(n <= 16)
{
if(*nbits <= 16)
{
if((*CurrentPtr > (length-1)) && (*nbits < n))
{
dbg_printf(("getbits: not enough data to parse!n"));
return 0;
}
*cword = (*cword << 16 ) | ((UINT32)(*((UINT8 *)(buffer + (*CurrentPtr)))) << 8) | (UINT32)(*((UINT8 *)(buffer + (*CurrentPtr) + 1)));
*nbits += 16;
(*CurrentPtr) += 2;
}
*nbits -= n;
return ((*cword >> *nbits) & ((1<<n)-1));
}
else
{
return ((getbits(buffer,CurrentPtr,cword,nbits,(n-16),length) << 16) | getbits(buffer,CurrentPtr,cword,nbits,16,length));
}
}
///////////////////////////////////////////////////////////////////////////
// Function name : _mp4ReadAudioSpecificConfig
// Purpose : parse AudioSpecificConfig info
// Input Parameters : AudioSpecificConfig - The start address to AudioSpecificConfig.
//
// Return type : TRUE - if succeeded, FALSE otherwise.
///////////////////////////////////////////////////////////////////////////
static BOOL _mp4ReadAudioSpecificConfig(BYTE *AudioSpecificConfig, UINT16 length)
{
UINT8 audioObjectType;
UINT8 CurrentPtr = 0;
UINT32 cword=0;
UINT8 nbits=0;
UINT8 i;
audioObjectType = (UINT8)getbits(AudioSpecificConfig,&CurrentPtr,&cword,&nbits,5, length);
_mpeg4AudioInfo_AAC.samplingFrequencyIndex = getbits(AudioSpecificConfig,&CurrentPtr,&cword,&nbits,4, length);
if(_mpeg4AudioInfo_AAC.samplingFrequencyIndex == 0xF)
{
_mpeg4AudioSamplesPerSec = getbits(AudioSpecificConfig,&CurrentPtr,&cword,&nbits,24, length);
}
else
{
_mpeg4AudioSamplesPerSec = SAMPLE_RATE_TABLE[_mpeg4AudioInfo_AAC.samplingFrequencyIndex % 16];
}
_mpeg4AudioInfo_AAC.channelConfiguration = getbits(AudioSpecificConfig,&CurrentPtr,&cword,&nbits,4, length);
if((audioObjectType != 1) && (audioObjectType != 2) && (audioObjectType != 3)
&& (audioObjectType != 4) && (audioObjectType != 6) && (audioObjectType != 7)
&& (audioObjectType != 17) && (audioObjectType != 19) && (audioObjectType != 20)
&& (audioObjectType != 21) && (audioObjectType != 22) && (audioObjectType != 23)
)
{
return FALSE;
}
getbits(AudioSpecificConfig,&CurrentPtr,&cword,&nbits,1, length);
if(getbits(AudioSpecificConfig,&CurrentPtr,&cword,&nbits,1, length))
{
getbits(AudioSpecificConfig,&CurrentPtr,&cword,&nbits,14, length);
}
getbits(AudioSpecificConfig,&CurrentPtr,&cword,&nbits,1, length);
if(!_mpeg4AudioInfo_AAC.channelConfiguration)
{
getbits(AudioSpecificConfig,&CurrentPtr,&cword,&nbits,10, length);
_mpeg4AudioInfo_AAC.num_front_channel_elements = getbits(AudioSpecificConfig,&CurrentPtr,&cword,&nbits,4, length);
_mpeg4AudioInfo_AAC.num_side_channel_elements = getbits(AudioSpecificConfig,&CurrentPtr,&cword,&nbits,4, length);
_mpeg4AudioInfo_AAC.num_back_channel_elements = getbits(AudioSpecificConfig,&CurrentPtr,&cword,&nbits,4, length);
_mpeg4AudioInfo_AAC.num_lfe_channel_elements = getbits(AudioSpecificConfig,&CurrentPtr,&cword,&nbits,2, length);
getbits(AudioSpecificConfig,&CurrentPtr,&cword,&nbits,7, length);
if(getbits(AudioSpecificConfig,&CurrentPtr,&cword,&nbits,1, length))
{
getbits(AudioSpecificConfig,&CurrentPtr,&cword,&nbits,4, length);
}
if(getbits(AudioSpecificConfig,&CurrentPtr,&cword,&nbits,1, length))
{
getbits(AudioSpecificConfig,&CurrentPtr,&cword,&nbits,4, length);
}
if(getbits(AudioSpecificConfig,&CurrentPtr,&cword,&nbits,1, length))
{
getbits(AudioSpecificConfig,&CurrentPtr,&cword,&nbits,3, length);
}
for(i=0; i < _mpeg4AudioInfo_AAC.num_front_channel_elements; i++)
{
_mpeg4AudioInfo_AAC.main_channel_elements[i].front_element_is_cpe = getbits(AudioSpecificConfig,&CurrentPtr,&cword,&nbits,1, length);
_mpeg4AudioInfo_AAC.main_channel_elements[i].front_element_tag_select = getbits(AudioSpecificConfig,&CurrentPtr,&cword,&nbits,4, length);
}
for(i=0; i < _mpeg4AudioInfo_AAC.num_side_channel_elements; i++)
{
_mpeg4AudioInfo_AAC.main_channel_elements[i].side_element_is_cpe = getbits(AudioSpecificConfig,&CurrentPtr,&cword,&nbits,1, length);
_mpeg4AudioInfo_AAC.main_channel_elements[i].side_element_tag_select = getbits(AudioSpecificConfig,&CurrentPtr,&cword,&nbits,4, length);
}
for(i=0; i < _mpeg4AudioInfo_AAC.num_back_channel_elements; i++)
{
_mpeg4AudioInfo_AAC.main_channel_elements[i].back_element_is_cpe = getbits(AudioSpecificConfig,&CurrentPtr,&cword,&nbits,1, length);
_mpeg4AudioInfo_AAC.main_channel_elements[i].back_element_tag_select = getbits(AudioSpecificConfig,&CurrentPtr,&cword,&nbits,4, length);
}
for(i=0; i < _mpeg4AudioInfo_AAC.num_lfe_channel_elements; i++)
{
_mpeg4AudioInfo_AAC.lfe_channel_elements[i].lfe_element_tag_select = getbits(AudioSpecificConfig,&CurrentPtr,&cword,&nbits,4, length);
}
}
return TRUE;
}
#endif //D_ENABLE_AAC_SUPPORT
///////////////////////////////////////////////////////////////////////////
// Function name : _mp4ReadSubPictureSpecificConfig
// Purpose : parse SubPictureSpecificConfig info
// Input Parameters : SubPictureConfig - The start address to SubPictureConfig.
//
// Return type : TRUE - if succeeded, FALSE otherwise.
///////////////////////////////////////////////////////////////////////////
static BOOL _mp4ReadSubPictureConfig(BYTE *SubPictureConfig, UINT16 length)
{
UINT16 uiCount = 0;
while(uiCount < (length-3))
{
I49_ParameterWrite(SPPALETTE_ADDR, ((WORD)(SubPictureConfig[uiCount+1])&0xFF)); /* m.s. 16 bits */
I49_ParameterWrite(SPPALETTE_ADDR, (((WORD) (SubPictureConfig[uiCount+2])<<8) |
((WORD)(SubPictureConfig[uiCount+3])))); /* l.s. 16 bits */
uiCount += 4;
}
while (uiCount < (64 -3))
{
I49_ParameterWrite(SPPALETTE_ADDR, 0); /* m.s. 16 bits */
I49_ParameterWrite(SPPALETTE_ADDR, 0); /* l.s. 16 bits */
uiCount += 4;
}
return TRUE;
}
///////////////////////////////////////////////////////////////////////////
// Function name : _mp4GetNextBox
// Purpose : Returns the next BOX in the file.
// Input Parameters : dwClipStartAddr - The start address to get the BOX.
// dwOffset - The offset to read the BOX.
// Return type : TRUE - if succeeded, FALSE otherwise.
// Output Parameters : pMP4Box - The BOX info which was read.
///////////////////////////////////////////////////////////////////////////
static BOOL _mp4GetNextBox(DWORD dwClipStartAddr, DWORD* dwOffset, MP4Box* pMP4Box)
{
BYTE Temp[8];
if (FALSE == AuxCache_GetBytes(dwClipStartAddr, *dwOffset, (WORD)8, &Temp[0]))
{
dbg_printf(("FATAL: _mp4GetNextBox() Failed [1]n"));
return FALSE;
}
*dwOffset += 8UL;
pMP4Box->ulSize = _toBe32(&Temp[0]);
memcpy((BYTE*)&pMP4Box->ulType,&Temp[4],4);
if (pMP4Box->ulSize == 1UL) // large size
{
if (FALSE == AuxCache_GetBytes(dwClipStartAddr, *dwOffset, 8, &Temp[0]))
{
dbg_printf(("FATAL: _mp4GetNextBox() Failed [2]n"));
return FALSE;
}
*dwOffset += 8UL;
pMP4Box->ulSize = _toBe32(&Temp[4]);
pMP4Box->ulSize -= 8UL;
}
if (0 == strnicmp((LPSTR)(pMP4Box->ulSize), MP4_USER_TYPE_ID, FOURCC_FIELD_LENGTH))
{
*dwOffset += 16UL;
pMP4Box->ulSize -= 16UL;
}
pMP4Box->ulSize -= 8UL;
return TRUE;
}
///////////////////////////////////////////////////////////////////////////
// Function name : _mp4ReadDescr
// Purpose : Returns the Descriptor Tag.
// Input Parameters : dwClipAddr - The start address to get the Descriptor.
// dwOffset - The offset to read the Descriptor.
// Return type : TRUE - if succeeded, FALSE otherwise.
// Output Parameters : Tag - The descriptor tag.
///////////////////////////////////////////////////////////////////////////
static int _mp4ReadDescr(DWORD dwStartAddr, DWORD *dwOffset, int *tag)
{
int len = 0;
int count = 4;
int i = 1;
BYTE TempBuff[5];
if (FALSE == AuxCache_GetBytes(dwStartAddr, *dwOffset, (WORD)5, &TempBuff[0]))
return len;
(*dwOffset)++;
*tag = (int)TempBuff[0];
while (count--)
{
int c;
c = (int)TempBuff[i++];
(*dwOffset)++;
len = (len << 7) | (c & 0x7f);
if (!(c & 0x80))
break;
}
return len;
}
///////////////////////////////////////////////////////////////////////////
// Function name : _mp4StoreSampleTable
// Purpose : store the sample table to DRAM
// Input Parameters : dwStartAddr - The start address to get the Sample Table.
// dwOffset - The offset to read the Sample Table.
// dwSampleTableSize - the size of the Sampe Table
// dwSampleTableAddr - The store DRAM start address of the Sample Table.
// b64Bits - "co64", discard the high 32bits
// Return type : TRUE - if succeeded, FALSE otherwise.
// Output Parameters :
///////////////////////////////////////////////////////////////////////////
static BOOL _mp4StoreSampleTable(DWORD dwStartAddr, DWORD dwOffset, DWORD dwSampleTableSize, DWORD dwSampleTableAddr, BOOL b64Bits)
{
DWORD dwSize = dwSampleTableSize;
DWORD dwDRAMAddr = dwSampleTableAddr;
WORD wCacheSize;
WORD wStoreSize;
BOOL bError = TRUE;
BOOL bFirstTime = TRUE;
DWORD dwSampleTableStartAddr;
DWORD dwSampleTableOffset;
DWORD dwSampleTableSizeSave;
#ifdef PRINTF_MP4_SMAPLE_TABLE
DWORD dwPrintfOffset = dwOffset;
DWORD dwPrintfCount = 0;
int i;
#endif
dwSampleTableStartAddr = dwStartAddr + (dwOffset/2048UL);
dwSampleTableOffset = dwOffset%2048UL;
dwSampleTableSizeSave = dwSampleTableSize + dwSampleTableOffset;
while (dwSize > 0)
{
wCacheSize = (dwSize < MAX_SAMPLE_TABLE_BUFFER_SIZE) ? (WORD)dwSize : MAX_SAMPLE_TABLE_BUFFER_SIZE;
#ifdef SUPPORT_FLASH_CARD
if(IS_PLAYING_CARD)
{
if (!AuxCache_GetBytes(dwSampleTableStartAddr, dwSampleTableOffset, wCacheSize, (BYTE*)&_MP4SharedBuff[0]))
{
bError = FALSE;
dbg_printf(("_mp4StoreSampleTable(): AuxCache_GetBytes() Fail[] n"));
break;
}
}
else
#endif
if (!AuxCache_GetFile(dwSampleTableStartAddr, dwSampleTableOffset, wCacheSize, dwSampleTableSizeSave, bFirstTime, (BYTE*)&_MP4SharedBuff[0]))
{
bError = FALSE;
dbg_printf(("_mp4StoreSampleTable(): AuxCache_GetFile() Fail[] n"));
break;
}
if(bError == FALSE)
break;
#ifdef PRINTF_MP4_SMAPLE_TABLE
if (dwPrintfCount < MAX_PRINTF_TABLE_SIZE)
{
for (wStoreSize = 0; wStoreSize < wCacheSize; wStoreSize+= 16)
{
dbg_printf(("%lx ",dwPrintfOffset));
for(i=0;i<16;i++)
dbg_printf(("%2x ",_MP4SharedBuff[wStoreSize+i]));
dbg_printf(("n"));
dwPrintfOffset += 16;
}
}
dwPrintfCount += wCacheSize;
#endif
if(TRUE == b64Bits)
{
WORD wOffset=0;
WORD wCacheSizeTemp = wCacheSize;
while(wCacheSizeTemp)
{
memcpy((BYTE*)&_MP4SharedBuff[4*wOffset],(BYTE*)&_MP4SharedBuff[(8*wOffset)+4],4);
wCacheSizeTemp -= 8;
wOffset += 1;
}
wStoreSize = wCacheSize/2;
}
else
{
wStoreSize = wCacheSize;
}
{
WORD wInOffset;
BYTE temp;
for (wInOffset = 0; wInOffset < wStoreSize; wInOffset+=4)
{
temp = _MP4SharedBuff[wInOffset+3];
_MP4SharedBuff[wInOffset+3] = _MP4SharedBuff[wInOffset];
_MP4SharedBuff[wInOffset] = temp;
temp = _MP4SharedBuff[wInOffset +2];
_MP4SharedBuff[wInOffset+2] = _MP4SharedBuff[wInOffset+1];
_MP4SharedBuff[wInOffset+1] = temp;
}
}
wai_sem(SEM_DRAM_ID);
I49_WriteDRAMData(dwDRAMAddr,(UINT16*)&_MP4SharedBuff[0], (wStoreSize/2));
sig_sem(SEM_DRAM_ID);
dwSize -= wCacheSize;
dwDRAMAddr += (wStoreSize/2); // in words
dwSampleTableOffset += wCacheSize;
bFirstTime = FALSE;
}
AuxCache_GetFileTerminate();
return bError;
}
#ifdef MP4_PACK_STSC
static BOOL _mp4StorePackSTSC(DWORD dwStartAddr, DWORD dwOffset, /*DWORD dwSampeTableEntryCount,*/ DWORD dwSampleTableSize, DWORD dwSampleTableAddr)
{
DWORD dwSize = dwSampleTableSize;
DWORD dwDRAMAddr = dwSampleTableAddr;
WORD wCacheSize;
WORD wStoreSize;
BOOL bError = TRUE;
BOOL bFirstTime = TRUE;
DWORD dwSampleTableStartAddr;
DWORD dwSampleTableOffset;
DWORD dwSampleTableSizeSave;
DWORD dwFirstChunk;
DWORD dwSamplePreChunk;
DWORD dwPackSTSC;
#ifdef PRINTF_MP4_SMAPLE_TABLE
DWORD dwPrintfOffset = dwOffset;
DWORD dwPrintfCount = 0;
int i;
#endif
dwSampleTableStartAddr = dwStartAddr + (dwOffset/2048UL);
dwSampleTableOffset = dwOffset%2048UL;
dwSampleTableSizeSave = dwSampleTableSize + dwSampleTableOffset;
#define MAX_STSC_BUFFER_SIZE ((MAX_SAMPLE_TABLE_BUFFER_SIZE/sizeof(MP4SampleToChunkEntry))*sizeof(MP4SampleToChunkEntry))
while (dwSize > 0)
{
wCacheSize = (dwSize < MAX_STSC_BUFFER_SIZE) ? (WORD)dwSize : MAX_STSC_BUFFER_SIZE;
#ifdef SUPPORT_FLASH_CARD
if(IS_PLAYING_CARD)
{
if (!AuxCache_GetBytes(dwSampleTableStartAddr, dwSampleTableOffset, wCacheSize, (BYTE*)&_MP4SharedBuff[0]))
{
bError = FALSE;
dbg_printf(("_mp4StorePackSTSC(): AuxCache_GetBytes() Fail[] n"));
break;
}
}
else
#endif
if (!AuxCache_GetFile(dwSampleTableStartAddr, dwSampleTableOffset, wCacheSize, dwSampleTableSizeSave, bFirstTime, (BYTE*)&_MP4SharedBuff[0]))
{
bError = FALSE;
dbg_printf(("_mp4StorePackSTSC(): AuxCache_GetFile() Fail[] n"));
break;
}
#ifdef PRINTF_MP4_SMAPLE_TABLE
if (dwPrintfCount < MAX_PRINTF_TABLE_SIZE)
{
for (wStoreSize = 0; wStoreSize < wCacheSize; wStoreSize+= 16)
{
dbg_printf(("%lx ",dwPrintfOffset));
for(i=0;i<16;i++)
dbg_printf(("%2x ",_MP4SharedBuff[wStoreSize+i]));
dbg_printf(("n"));
dwPrintfOffset += 16;
}
}
dwPrintfCount += wCacheSize;
#endif
for (wStoreSize = 0; wStoreSize < wCacheSize; wStoreSize+= 12)
{
dwFirstChunk = _toBe32((BYTE*)&_MP4SharedBuff[wStoreSize]);
dwSamplePreChunk = _toBe32((BYTE*)&_MP4SharedBuff[wStoreSize+4]);
if (dwFirstChunk >= 0x100000UL)
{
bError = FALSE;
tr_printf(("nERROR: too many chunks! dwFirstChunk: %ldn", dwFirstChunk));
}
if (dwSamplePreChunk >= 0x1000UL)
{
bError = FALSE;
tr_printf(("nERROR: too many sample per chunk! dwSamplePreChunk: %ldn",dwSamplePreChunk));
}
dwPackSTSC = (dwFirstChunk<<12) + dwSamplePreChunk;
memcpy((BYTE*)&_MP4SharedBuff[wStoreSize/3],(BYTE*)&dwPackSTSC,4);
}
if(bError == FALSE)
break;
wai_sem(SEM_DRAM_ID);
I49_WriteDRAMData(dwDRAMAddr,(UINT16*)&_MP4SharedBuff[0], (wStoreSize/6));
sig_sem(SEM_DRAM_ID);
dwSize -= wCacheSize;
dwDRAMAddr += (wStoreSize/6); // in words
dwSampleTableOffset += wCacheSize;
bFirstTime = FALSE;
}
AuxCache_GetFileTerminate();
return bError;
}
static BOOL _mp4CheckIfPackSTSC(DWORD dwSTSCEntryCount, DWORD dwSyncSampleAddr)
{
DWORD dwSTSCEndAddr;
DWORD dwSyncStartAddr;
DWORD dwEntrySize;
dwEntrySize = _uiMPEG4NextIndexEntry * sizeof(MP4VideoSyncEntry);
dwSyncStartAddr = dwSyncSampleAddr - (dwEntrySize>>1);
dwSyncStartAddr = (dwSyncStartAddr>>9)<<9;
dwEntrySize = dwSTSCEntryCount * sizeof(MP4SampleToChunkEntry);
dwSTSCEndAddr = _dwMP4SampleTableAddr + (dwEntrySize>>1);
dwSTSCEndAddr = ((dwSTSCEndAddr + 0x1FFUL)>>9)<<9;
if (dwSTSCEndAddr >= dwSyncStartAddr)
{
dwSTSCEndAddr = _dwMP4SampleTableAddr + ((dwEntrySize>>1)/3);
dwSTSCEndAddr = ((dwSTSCEndAddr + 0x1FFUL)>>9)<<9;
if (dwSTSCEndAddr >= dwSyncStartAddr)
{
tr_printf(("nnNo enough memory space to store STSC!nn"));
}
return TRUE;
}
else
return FALSE;
}
#endif
#ifdef MP4_PACK_STCO
static BOOL _mp4StoreSTCOTable(DWORD dwStartAddr, DWORD dwOffset, DWORD dwEntryCount, DWORD dwSampleTableAddr, BOOL b64Bits)
{
DWORD dwSize;
DWORD dwDRAMAddr = dwSampleTableAddr;
WORD wCacheSize;
WORD wStoreSize;
BOOL bError = TRUE;
BOOL bFirstTime = TRUE;
DWORD dwSampleTableStartAddr;
DWORD dwSampleTableOffset;
DWORD dwSampleTableSizeSave;
DWORD dwChunkOffset;
DWORD dwPreChunkOffset;
DWORD dwSampleTableSize;
WORD wOffset;
WORD wPackOffset;
#ifdef PRINTF_MP4_SMAPLE_TABLE
DWORD dwPrintfOffset = dwOffset;
DWORD dwPrintfCount = 0;
int i;
#endif
dwSampleTableSize = dwEntryCount * sizeof(DWORD) * (b64Bits ? 2 : 1);
dwSize = dwSampleTableSize;
dwSampleTableStartAddr = dwStartAddr + (dwOffset/2048UL);
dwSampleTableOffset = dwOffset%2048UL;
dwSampleTableSizeSave = dwSampleTableSize + dwSampleTableOffset;
while (dwSize > 0)
{
wCacheSize = (dwSize < MAX_SAMPLE_TABLE_BUFFER_SIZE) ? (WORD)dwSize : MAX_SAMPLE_TABLE_BUFFER_SIZE;
#ifdef SUPPORT_FLASH_CARD
if(IS_PLAYING_CARD)
{
if (!AuxCache_GetBytes(dwSampleTableStartAddr, dwSampleTableOffset, wCacheSize, (BYTE*)&_MP4SharedBuff[0]))
{
bError = FALSE;
dbg_printf(("_mp4StoreSampleTable(): AuxCache_GetBytes() Fail[] n"));
break;
}
}
else
#endif
if (!AuxCache_GetFile(dwSampleTableStartAddr, dwSampleTableOffset, wCacheSize, dwSampleTableSizeSave, bFirstTime, (BYTE*)&_MP4SharedBuff[0]))
{
bError = FALSE;
dbg_printf(("_mp4StoreSampleTable(): AuxCache_GetFile() Fail[] n"));
break;
}
if(bError == FALSE)
break;
#ifdef PRINTF_MP4_SMAPLE_TABLE
if (dwPrintfCount < MAX_PRINTF_TABLE_SIZE)
{
for (wStoreSize = 0; wStoreSize < wCacheSize; wStoreSize+= 16)
{
dbg_printf(("%lx ",dwPrintfOffset));
for(i=0;i<16;i++)
dbg_printf(("%2x ",_MP4SharedBuff[wStoreSize+i]));
dbg_printf(("n"));
dwPrintfOffset += 16;
}
}
dwPrintfCount += wCacheSize;
#endif
if(TRUE == b64Bits)
{
WORD wCacheSizeTemp = wCacheSize;
wOffset = 0;
while(wCacheSizeTemp)
{
memcpy((BYTE*)&_MP4SharedBuff[4*wOffset],(BYTE*)&_MP4SharedBuff[(8*wOffset)+4],4);
wCacheSizeTemp -= 8;
wOffset += 1;
}
wStoreSize = wCacheSize/2;
}
else
{
wStoreSize = wCacheSize;
}
// if (TRUE == bNeedPack)
{
DWORD dwChunkSize;
wOffset = 0;
wPackOffset = 0;
if (TRUE == bFirstTime)
{
dwPreChunkOffset = _toBe32(&_MP4SharedBuff[0]);
wai_sem(SEM_DRAM_ID);
I49_WriteDRAMData(dwDRAMAddr,(UINT16*)&dwPreChunkOffset, 2); // first chunk offset
sig_sem(SEM_DRAM_ID);
dwDRAMAddr += 2; // in words
}
while (wOffset<wStoreSize/4)
{
dwChunkOffset = _toBe32(&_MP4SharedBuff[4*wOffset]);
dwChunkSize = dwChunkOffset - dwPreChunkOffset;
dwPreChunkOffset = dwChunkOffset;
if (wOffset%2 == 0)
{
_MP4SharedBuff[wPackOffset++] = (BYTE)dwChunkSize;
_MP4SharedBuff[wPackOffset++] = (BYTE)(dwChunkSize>>8);
_MP4SharedBuff[wPackOffset] = (BYTE)(dwChunkSize>>16);
}
else
{
_MP4SharedBuff[wPackOffset++] += (BYTE)(dwChunkSize <<4);
_MP4SharedBuff[wPackOffset++] = (BYTE)(dwChunkSize>>4);
_MP4SharedBuff[wPackOffset++] = (BYTE)(dwChunkSize>>12);
}
wOffset++;
}
wai_sem(SEM_DRAM_ID);
I49_WriteDRAMData(dwDRAMAddr,(UINT16*)&_MP4SharedBuff[0], ((wPackOffset+1)/2));
sig_sem(SEM_DRAM_ID);
dwDRAMAddr += (wPackOffset/2); // in words
}
// else
// {
// wai_sem(SEM_DRAM_ID);
// I49_WriteDRAMData(dwDRAMAddr,(UINT16*)&_MP4SharedBuff[0], (wStoreSize/2));
// sig_sem(SEM_DRAM_ID);
// dwDRAMAddr += (wStoreSize/2); // in words
// }
dwSize -= wCacheSize;
dwSampleTableOffset += wCacheSize;
bFirstTime = FALSE;
}
AuxCache_GetFileTerminate();
return bError;
}
static void _mp4LoadSTCOTable(DWORD dwSTCODRAMAddr, DWORD* mp4ChunkOffsetBuff,DWORD* dwPreChunkOffset)
{
BYTE packBuff[MP4_PACK_STCO_BUFF_SIZE];
WORD wOffset;
WORD wPackOffset = 0;
DWORD dwChunkSize;
wai_sem(SEM_DRAM_ID);
I49_ReadDRAMData(dwSTCODRAMAddr,(UINT16*)&packBuff, MP4_PACK_STCO_BUFF_SIZE_IN_WORD);
sig_sem(SEM_DRAM_ID);
for (wOffset=0;wOffset<MP4_CHUNK_OFFSET_BUFF_SIZE;wOffset++)
{
if (wOffset%2 == 0)
{
dwChunkSize = packBuff[wPackOffset++];
dwChunkSize += (((DWORD)(packBuff[wPackOffset++])) << 8);
dwChunkSize += (((DWORD)(packBuff[wPackOffset] & 0xF)) << 16);
}
else
{
dwChunkSize = packBuff[wPackOffset++] >> 4;
dwChunkSize += (((DWORD)(packBuff[wPackOffset++])) << 4);
dwChunkSize += (((DWORD)(packBuff[wPackOffset++])) << 12);
}
*dwPreChunkOffset += dwChunkSize;
mp4ChunkOffsetBuff[wOffset] = *dwPreChunkOffset;
}
}
static BOOL _mp4CheckSampleTable(BOOL* bPackTansferSize, BOOL* bPackSTCO )
{
DWORD dwTansferChunkTableSize;
DWORD dwVideoSyncTableSize;
DWORD dwAudioSyncTableSize;
DWORD dwSTCOSize;
DWORD dwVideoSTSSSize;
DWORD dwSizeFromACBtoAPP;
DWORD dwSize;
dwSizeFromACBtoAPP = 2*(COLOCATED_INFO_AVI - SAMPLE_TABLE_START_ADDR) - 0x20000; // -128KB
dwSTCOSize = _dwMP4ChunkSizeEntryTotal * 4UL;
dwVideoSTSSSize = _uiMPEG4NextIndexEntry * 4UL;
dwTansferChunkTableSize = _dwMP4ChunkSizeEntryTotal * 4UL; // 20bit every chunk
dwVideoSyncTableSize = _uiMPEG4NextIndexEntry * sizeof(MP4VideoSyncEntry);
dwAudioSyncTableSize = _mpeg4AudioAvailableNum * _uiMPEG4NextIndexEntry * sizeof(MP4VideoSyncEntry);
dwSize = dwSTCOSize + dwVideoSTSSSize + dwTansferChunkTableSize + dwVideoSyncTableSize + dwAudioSyncTableSize;
*bPackTansferSize = FALSE;
*bPackSTCO = FALSE;
if (dwSize > dwSizeFromACBtoAPP)
{
*bPackTansferSize = TRUE;
dwTansferChunkTableSize = (_dwMP4ChunkSizeEntryTotal * 20UL) / 8UL;
dwSize = dwSTCOSize + dwVideoSTSSSize + dwTansferChunkTableSize + dwVideoSyncTableSize + dwAudioSyncTableSize;
if (dwSize > dwSizeFromACBtoAPP)
{
*bPackSTCO = TRUE;
dwSTCOSize = (_dwMP4ChunkSizeEntryTotal * 20UL) / 8UL;
dwSize = dwSTCOSize + dwVideoSTSSSize + dwTansferChunkTableSize + dwVideoSyncTableSize + dwAudioSyncTableSize;
if (dwSize > dwSizeFromACBtoAPP)
{
tr_printf(("nnNo enough SDRAM to Process MP4 !nn")); // RB_TBD
tr_printf(("The total chunk number is %ldn", _dwMP4ChunkSizeEntryTotal));
return FALSE;
}
}
}
return TRUE;
}
#endif
#ifdef MP4_STORE_SAMPLETABLE_AFTER
static BOOL _mp4SampleTableProcessing(DWORD dwStartAddr)
{
WORD wSampleTableAddrEXAddr = SC_MPEG4_VIDEO_SAMPLE_TABLE_ADDREX_BUFF_ADDR;
MP4_CODEC_TYPE codecType = CODEC_TYPE_VIDEO;
MP4StreamSampleTableAddrEX mp4StreamSampleTableAddrEX;
DWORD dwmp4VideoSTSSStartAdd;
DWORD dwSyncSampleAddr; // descend
DWORD dwChunkSizeAddr;
// DWORD dwPreSampleTableAddr;
BYTE currAudioStreamNum;
BYTE currSubStreamNum;
DWORD dwEntrySize;
//BOOL bPackSTSC = FALSE;
BOOL bPackSTCO = FALSE;
//BOOL bPackSTSZ = FALSE;
BOOL bPackTansferSize;
if (_bMPEG4IsIndexProcessed == TRUE)
return TRUE;
#if MP4_PACK_STCO
if (FALSE == _mp4CheckSampleTable(&bPackTansferSize, &bPackSTCO ))
{
return FALSE;
}
#endif
_dwMP4SampleTableAddr = SAMPLE_TABLE_START_ADDR; // ACB start address
_dwMPEG4ProcessingEndAddr = MPEG4_PROCESSING_BUFF_ADDR; // Colocated AVI info
dwSyncSampleAddr = _dwMPEG4ProcessingEndAddr;
if (_mpeg4VideoStreamID != NO_STREAM)
{
// video sample table address
sc_GetBytes(wSampleTableAddrEXAddr,
0,SIZE_OF_MP4StreamSampleTableAddrEX,(BYTE*)&mp4StreamSampleTableAddrEX);
#if MP4_PACK_STCO
mp4PackSTCO = bPackSTCO;
#else
mp4PackSTCO = FALSE;
#endif
// STCO
if (FALSE == mp4PackSTCO)
{
dwEntrySize = mp4STCOEntryCount * sizeof(DWORD) * (mp4CO64 ? 2 : 1);
_mp4StoreSampleTable(dwStartAddr, mp4STCOOffsetInFile, dwEntrySize, _dwMP4SampleTableAddr, mp4CO64);
mp4STCOStartAddr = _dwMP4SampleTableAddr;
_dwMP4SampleTableAddr += ((mp4STCOEntryCount * sizeof(DWORD))>>1);
_dwMP4SampleTableAddr = ((_dwMP4SampleTableAddr + 0x1FFUL)>>9)<<9;
}
#ifdef MP4_PACK_STCO
else
{
tr_printf(("Video Pack STCOn"));
dwEntrySize = mp4STCOEntryCount * sizeof(DWORD) * (mp4CO64 ? 2 : 1);
_mp4StoreSTCOTable(dwStartAddr, mp4STCOOffsetInFile, mp4STCOEntryCount, _dwMP4SampleTableAddr, mp4CO64);
mp4STCOStartAddr = _dwMP4SampleTableAddr;
_dwMP4SampleTableAddr += (((mp4STCOEntryCount+3)/4) * MP4_PACK_STCO_BUFF_SIZE_IN_WORD);
_dwMP4SampleTableAddr += (16*sizeof(DWORD));
_dwMP4SampleTableAddr = ((_dwMP4SampleTableAddr + 0x1FFUL)>>9)<<9;
}
#endif
tr_printf(("Video dwSampleTableAddr - stco : %ld KB, Size: %ld KBn", mp4STCOStartAddr>>9,(_dwMP4SampleTableAddr-mp4STCOStartAddr)>>9));
// STSS
{
dwEntrySize = mp4STSSEntryCount * sizeof(DWORD);
_mp4StoreSampleTable(dwStartAddr, mp4STSSOffsetInFile, dwEntrySize, _dwMP4SampleTableAddr, FALSE);
mp4STSSStartAdd = _dwMP4SampleTableAddr;
_dwMP4SampleTableAddr += (dwEntrySize>>1);
_dwMP4SampleTableAddr = ((_dwMP4SampleTableAddr + 0x1FFUL)>>9)<<9;
tr_printf(("Video dwSampleTableAddr - stss : %ld KB, Size: %ld KBn", mp4STSSStartAdd>>9,(_dwMP4SampleTableAddr-mp4STSSStartAdd)>>9));
}
// stsc,
#ifdef MP4_PACK_STSC
mp4PackSTSC = _mp4CheckIfPackSTSC(mp4STSCEntryCount, dwSyncSampleAddr);
#else
mp4PackSTSC = FALSE;
#endif
// STSC
if (FALSE == mp4PackSTSC)
{
dwEntrySize = mp4STSCEntryCount * sizeof(MP4SampleToChunkEntry);
_mp4StoreSampleTable(dwStartAddr, mp4STSCOffsetInFile, dwEntrySize, _dwMP4SampleTableAddr, FALSE);
mp4STSCStartAddr = _dwMP4SampleTableAddr;
_dwMP4SampleTableAddr += (dwEntrySize>>1);
_dwMP4SampleTableAddr = ((_dwMP4SampleTableAddr + 0x1FFUL)>>9)<<9;
}
#ifdef MP4_PACK_STSC
else
{
dwEntrySize = mp4STSCEntryCount * sizeof(MP4SampleToChunkEntry);
_mp4StorePackSTSC(dwStartAddr, mp4STSCOffsetInFile, /*mp4STSCEntryCount,*/ dwEntrySize, _dwMP4SampleTableAddr);
mp4STSCStartAddr = _dwMP4SampleTableAddr;
_dwMP4SampleTableAddr += ((dwEntrySize/3)>>1);
_dwMP4SampleTableAddr = ((_dwMP4SampleTableAddr + 0x1FFUL)>>9)<<9;
tr_printf(("Video Pack STSCn"));
}
#endif
tr_printf(("Video dwSampleTableAddr - stsc : %ld KB, Size: %ld KBn", mp4STSCStartAddr>>9,(_dwMP4SampleTableAddr-mp4STSCStartAddr)>>9));
#if 0
if (mp4STCOEntryCount > 50000)
mp4PackSTSZ = TRUE; // max chunk offset delta is 0x1000000
else
#endif
mp4PackSTSZ = FALSE;
mp4ChunkSizeStartAddr = _dwMP4SampleTableAddr; // not used
mp4SyncEntryStartAddr = _dwMPEG4ProcessingEndAddr;
sc_SetBytes(wSampleTableAddrEXAddr,
0,SIZE_OF_MP4StreamSampleTableAddrEX,(BYTE*)&mp4StreamSampleTableAddrEX);
dwSyncSampleAddr = mp4SyncEntryStartAddr; //video
dwChunkSizeAddr = mp4ChunkSizeStartAddr; //video
dwmp4VideoSTSSStartAdd = mp4STSSStartAdd;
// video sample table processing
if (FALSE == _mp4StreamSampleTableProcessing(dwStartAddr, wSampleTableAddrEXAddr, &dwChunkSizeAddr, &dwSyncSampleAddr,
codecType, dwmp4VideoSTSSStartAdd))
{
dbg_printf(("_mp4SampleTableProcessing(): _mp4StreamSampleTableProcessing() Fail[] n"));
AuxCache_GetFileTerminate();
return FALSE;
}
AuxCache_GetFileTerminate();
tr_printf(("Video dwSyncSampleAddr: %ld KB, Size: %ld KBn",mp4SyncEntryStartAddr>>9, (mp4SyncEntryStartAddr - dwSyncSampleAddr)>>9));
_dwMP4SampleTableAddr = mp4STSCStartAddr; //"stsc" is not used again
}
else // if no video, every audio frame is key-frame, RB_TBD
{
dwChunkSizeAddr = _dwMP4SampleTableAddr;
dwSyncSampleAddr = MPEG4_PROCESSING_BUFF_ADDR;
}
codecType = CODEC_TYPE_AUDIO;
for (currAudioStreamNum = 0; currAudioStreamNum < _mpeg4AudioAvailableNum; currAudioStreamNum++)
{
wSampleTableAddrEXAddr = SC_MPEG4_AUDIO_SAMPLE_TABLE_ADDREX_BUFF_ADDR + (currAudioStreamNum * SIZE_OF_MP4StreamSampleTableAddrEX_IN_DWORD);
sc_GetBytes(wSampleTableAddrEXAddr,0,SIZE_OF_MP4StreamSampleTableAddrEX,(BYTE*)&mp4StreamSampleTableAddrEX);
#if 0
if (mp4STCOEntryCount > 50000)
mp4PackSTSZ = TRUE; // max chunk offset delta is 0x1000000
else
#endif
mp4PackSTSZ = FALSE;
#if MP4_PACK_STCO
mp4PackSTCO = bPackSTCO;
#else
mp4PackSTCO = FALSE;
#endif
// STCO
if (FALSE == mp4PackSTCO)
{
dwEntrySize = mp4STCOEntryCount * sizeof(DWORD) * (mp4CO64 ? 2 : 1);
_mp4StoreSampleTable(dwStartAddr, mp4STCOOffsetInFile, dwEntrySize, _dwMP4SampleTableAddr, mp4CO64);
mp4STCOStartAddr = _dwMP4SampleTableAddr;
_dwMP4SampleTableAddr += ((mp4STCOEntryCount * sizeof(DWORD))>>1);
_dwMP4SampleTableAddr = ((_dwMP4SampleTableAddr + 0x1FFUL)>>9)<<9;
}
#ifdef MP4_PACK_STCO
else
{
tr_printf(("Audio Pack STCOn"));
dwEntrySize = mp4STCOEntryCount * sizeof(DWORD) * (mp4CO64 ? 2 : 1);
_mp4StoreSTCOTable(dwStartAddr, mp4STCOOffsetInFile, mp4STCOEntryCount, _dwMP4SampleTableAddr, mp4CO64);
mp4STCOStartAddr = _dwMP4SampleTableAddr;
_dwMP4SampleTableAddr += (((mp4STCOEntryCount+3)/4) * MP4_PACK_STCO_BUFF_SIZE_IN_WORD);
_dwMP4SampleTableAddr += (16*sizeof(DWORD));
_dwMP4SampleTableAddr = ((_dwMP4SampleTableAddr + 0x1FFUL)>>9)<<9;
}
#endif
tr_printf(("Audio dwSampleTableAddr - stco : %ld KB, Size: %ld KBn", mp4STCOStartAddr>>9,(_dwMP4SampleTableAddr-mp4STCOStartAddr)>>9));
// stsc,
#ifdef MP4_PACK_STSC
mp4PackSTSC = _mp4CheckIfPackSTSC(mp4STSCEntryCount, dwSyncSampleAddr);
#else
mp4PackSTSC = FALSE;
#endif
// STSC
if (FALSE == mp4PackSTSC)
{
dwEntrySize = mp4STSCEntryCount * sizeof(MP4SampleToChunkEntry);
_mp4StoreSampleTable(dwStartAddr, mp4STSCOffsetInFile, dwEntrySize, _dwMP4SampleTableAddr, FALSE);
mp4STSCStartAddr = _dwMP4SampleTableAddr;
_dwMP4SampleTableAddr += (dwEntrySize>>1);
_dwMP4SampleTableAddr = ((_dwMP4SampleTableAddr + 0x1FFUL)>>9)<<9;
}
#ifdef MP4_PACK_STSC
else
{
dwEntrySize = mp4STSCEntryCount * sizeof(MP4SampleToChunkEntry);
_mp4StorePackSTSC(dwStartAddr, mp4STSCOffsetInFile, /*mp4STSCEntryCount,*/ dwEntrySize, _dwMP4SampleTableAddr);
mp4STSCStartAddr = _dwMP4SampleTableAddr;
_dwMP4SampleTableAddr += ((dwEntrySize/3)>>1);
_dwMP4SampleTableAddr = ((_dwMP4SampleTableAddr + 0x1FFUL)>>9)<<9;
tr_printf(("Audio Pack STSCn"));
}
#endif
tr_printf(("Audio dwSampleTableAddr - stsc : %ld KB, Size: %ld KBn", mp4STSCStartAddr>>9,(_dwMP4SampleTableAddr-mp4STSCStartAddr)>>9));
mp4SyncEntryStartAddr = dwSyncSampleAddr;
mp4ChunkSizeStartAddr = dwChunkSizeAddr;
sc_SetBytes(wSampleTableAddrEXAddr,0,SIZE_OF_MP4StreamSampleTableAddrEX,(BYTE*)&mp4StreamSampleTableAddrEX);
// read aduio stream info from DRAM
sc_GetBytes(SC_MPEG4_AUDIO_STREAM_INFO_ADDR,
(currAudioStreamNum * SIZE_OF_AUDIO_STREAM_INFO),
SIZE_OF_AUDIO_STREAM_INFO,
(BYTE*)&_mpeg4AudioStreamInfo
);
// audio sample table processing
if (FALSE == _mp4StreamSampleTableProcessing(dwStartAddr, wSampleTableAddrEXAddr, &dwChunkSizeAddr, &dwSyncSampleAddr,
codecType, dwmp4VideoSTSSStartAdd))
{
dbg_printf(("_mp4SampleTableProcessing(): _mp4StreamSampleTableProcessing() Fail[] n"));
AuxCache_GetFileTerminate();
return FALSE;
}
AuxCache_GetFileTerminate();
tr_printf(("Audio dwSyncSampleAddr: %ld KB, Size: %ld KBn",mp4SyncEntryStartAddr>>9, (mp4SyncEntryStartAddr - dwSyncSampleAddr)>>9));
_dwMP4SampleTableAddr = mp4STSCStartAddr; //"stsc" is not used again
#ifdef D_ENABLE_AAC_SUPPORT
if (_mpeg4AudioCodec == AAC)
{
sc_SetBytes(SC_MPEG4_AUDIO_STREAM_INFO_ADDR,
(currAudioStreamNum * SIZE_OF_AUDIO_STREAM_INFO),
SIZE_OF_AUDIO_STREAM_INFO,
(BYTE*)&_mpeg4AudioStreamInfo
);
}
#endif
}
codecType = CODEC_TYPE_SUBPICTURE;
for (currSubStreamNum = 0; currSubStreamNum < _mpeg4SubtitleAvailableNum; currSubStreamNum++)
{
wSampleTableAddrEXAddr = SC_MPEG4_SUBTITLE_SAMPLE_TABLE_ADDREX_BUFF_ADDR + (currSubStreamNum * SIZE_OF_MP4StreamSampleTableAddrEX_IN_DWORD);
sc_GetBytes(wSampleTableAddrEXAddr,0,SIZE_OF_MP4StreamSampleTableAddrEX,(BYTE*)&mp4StreamSampleTableAddrEX);
#if 0
if (mp4STCOEntryCount > 50000)
mp4PackSTSZ = TRUE; // max chunk offset delta is 0x1000000
else
#endif
mp4PackSTSZ = FALSE;
mp4PackSTCO = FALSE;
// STCO
if (FALSE == mp4PackSTCO)
{
dwEntrySize = mp4STCOEntryCount * sizeof(DWORD) * (mp4CO64 ? 2 : 1);
_mp4StoreSampleTable(dwStartAddr, mp4STCOOffsetInFile, dwEntrySize, _dwMP4SampleTableAddr, mp4CO64);
mp4STCOStartAddr = _dwMP4SampleTableAddr;
_dwMP4SampleTableAddr += ((mp4STCOEntryCount * sizeof(DWORD))>>1);
_dwMP4SampleTableAddr = ((_dwMP4SampleTableAddr + 0x1FFUL)>>9)<<9;
}
tr_printf(("Subtitle dwSampleTableAddr - stco : %ld KB, Size: %ld KBn", mp4STCOStartAddr>>9,(_dwMP4SampleTableAddr-mp4STCOStartAddr)>>9));
// read subtitle stream info from DRAM
sc_GetBytes(SC_MPEG4_SUBTITLE_STREAM_INFO_ADDR,
(currSubStreamNum * SIZE_OF_SUBTITLE_STREAM_INFO),
SIZE_OF_SUBTITLE_STREAM_INFO,
(BYTE*)&_mpeg4SubtitleStreamInfo
);
if (_mpeg4SubtitleType == INTERNAL_SUBP)
codecType = CODEC_TYPE_SUBPICTURE;
else if (_mpeg4SubtitleType == INTERNAL_SUBT)
codecType = CODEC_TYPE_SUBTITLE;
// "stts"
if (CODEC_TYPE_SUBTITLE == codecType || CODEC_TYPE_SUBPICTURE == codecType)
{
dwEntrySize = mp4STTSEntryCount * sizeof(MP4TimeToSampleEntry);
_mp4StoreSampleTable(dwStartAddr, mp4STTSOffsetInFile, dwEntrySize, _dwMP4SampleTableAddr, FALSE);
tr_printf(("dwSampleTableAddr - stts : 0x%lx, Size: 0x%lxn",_dwMP4SampleTableAddr,(dwEntrySize>>1)));
mp4STTSStartAddr = _dwMP4SampleTableAddr;
_dwMP4SampleTableAddr += (dwEntrySize>>1);
_dwMP4SampleTableAddr = ((_dwMP4SampleTableAddr + 0x1FFUL)>>9)<<9;
tr_printf(("Subtitle dwSampleTableAddr - stts : %ld KB, Size: %ld KBn", mp4STTSStartAddr>>9,(_dwMP4SampleTableAddr-mp4STTSStartAddr)>>9));
}
// stsc,
mp4PackSTSC = FALSE;
// STSC
if (FALSE == mp4PackSTSC)
{
dwEntrySize = mp4STSCEntryCount * sizeof(MP4SampleToChunkEntry);
_mp4StoreSampleTable(dwStartAddr, mp4STSCOffsetInFile, dwEntrySize, _dwMP4SampleTableAddr, FALSE);
mp4STSCStartAddr = _dwMP4SampleTableAddr;
_dwMP4SampleTableAddr += (dwEntrySize>>1);
_dwMP4SampleTableAddr = ((_dwMP4SampleTableAddr + 0x1FFUL)>>9)<<9;
}
#ifdef MP4_PACK_STSC
else
{
dwEntrySize = mp4STSCEntryCount * sizeof(MP4SampleToChunkEntry);
_mp4StorePackSTSC(dwStartAddr, mp4STSCOffsetInFile, /*mp4STSCEntryCount,*/ dwEntrySize, _dwMP4SampleTableAddr);
mp4STSCStartAddr = _dwMP4SampleTableAddr;
_dwMP4SampleTableAddr += ((dwEntrySize/3)>>1);
_dwMP4SampleTableAddr = ((_dwMP4SampleTableAddr + 0x1FFUL)>>9)<<9;
tr_printf(("Subtitle Pack STSCn"));
}
#endif
tr_printf(("Subtitle dwSampleTableAddr - stsc : %ld KB, Size: %ld KBn", mp4STSCStartAddr>>9,(_dwMP4SampleTableAddr-mp4STSCStartAddr)>>9));
mp4SyncEntryStartAddr = dwSyncSampleAddr;
mp4ChunkSizeStartAddr = dwChunkSizeAddr;
sc_SetBytes(wSampleTableAddrEXAddr,0,SIZE_OF_MP4StreamSampleTableAddrEX,(BYTE*)&mp4StreamSampleTableAddrEX);
// read subtitle stream info from DRAM
sc_GetBytes(SC_MPEG4_SUBTITLE_STREAM_INFO_ADDR,
(currSubStreamNum * SIZE_OF_SUBTITLE_STREAM_INFO),
SIZE_OF_SUBTITLE_STREAM_INFO,
(BYTE*)&_mpeg4SubtitleStreamInfo
);
if (_mpeg4SubtitleType == INTERNAL_SUBP)
codecType = CODEC_TYPE_SUBPICTURE;
else if (_mpeg4SubtitleType == INTERNAL_SUBT)
codecType = CODEC_TYPE_SUBTITLE;
// subpicture sample table processing
if (FALSE == _mp4StreamSampleTableProcessing(dwStartAddr, wSampleTableAddrEXAddr, &dwChunkSizeAddr, &dwSyncSampleAddr,
codecType, dwmp4VideoSTSSStartAdd))
{
dbg_printf(("_mp4SampleTableProcessing(): _mp4StreamSampleTableProcessing() Fail[] n"));
AuxCache_GetFileTerminate();
return FALSE;
}
AuxCache_GetFileTerminate();
tr_printf(("Subtitle dwSyncSampleAddr: %ld KB, Size: %ld KBn",mp4SyncEntryStartAddr>>9, (mp4SyncEntryStartAddr - dwSyncSampleAddr)>>9));
_dwMP4SampleTableAddr = mp4STSCStartAddr; //"stsc" is not used again
}
// Robin_0106_2005, some unused chunks in the media data
codecType = CODEC_TYPE_RESERVED;
for (currSubStreamNum = 0; currSubStreamNum < uiMP4ReservedNum; currSubStreamNum++)
{
wSampleTableAddrEXAddr = SC_MPEG4_RESERVED_SAMPLE_TABLE_ADDREX_BUFF_ADDR + (currSubStreamNum * SIZE_OF_MP4StreamSampleTableAddrEX_IN_DWORD);
sc_GetBytes(wSampleTableAddrEXAddr,0,SIZE_OF_MP4StreamSampleTableAddrEX,(BYTE*)&mp4StreamSampleTableAddrEX);
mp4PackSTCO = FALSE;
// STCO
if (FALSE == mp4PackSTCO)
{
dwEntrySize = mp4STCOEntryCount * sizeof(DWORD) * (mp4CO64 ? 2 : 1);
_mp4StoreSampleTable(dwStartAddr, mp4STCOOffsetInFile, dwEntrySize, _dwMP4SampleTableAddr, mp4CO64);
mp4STCOStartAddr = _dwMP4SampleTableAddr;
_dwMP4SampleTableAddr += ((mp4STCOEntryCount * sizeof(DWORD))>>1);
_dwMP4SampleTableAddr = ((_dwMP4SampleTableAddr + 0x1FFUL)>>9)<<9;
}
sc_SetBytes(wSampleTableAddrEXAddr,0,SIZE_OF_MP4StreamSampleTableAddrEX,(BYTE*)&mp4StreamSampleTableAddrEX);
}
_dwMP4ChunkSizeStartAddr = dwSyncSampleAddr;
return TRUE;
}
#endif
///////////////////////////////////////////////////////////////////////////
// Function name : _mp4ReadBox_ESDS
// Purpose : store the video/audio header data to DRAM
// Input Parameters : dwClipAddr - The start address to get the Descriptor.
// dwOffset - The offset to read the Descriptor.
// Return type : TRUE - if succeeded, FALSE otherwise.
// Output Parameters : len - the header data length
///////////////////////////////////////////////////////////////////////////
static BOOL _mp4ReadBox_ESDS(DWORD dwStartAddr, DWORD dwOffset, MP4_CODEC_TYPE trackCodecType, int *len)
{
int tag,length;
DWORD dwOffset_Temp;
BYTE *pHeaderDataBuff;
dwOffset_Temp = dwOffset + 4UL;
length = _mp4ReadDescr(dwStartAddr, &dwOffset_Temp, &tag);
if(tag == MP4_ES_DESCR_Tag)
{
dwOffset_Temp += 3UL;
length = _mp4ReadDescr(dwStartAddr, &dwOffset_Temp, &tag);
if(tag == MP4_DEC_CONFIG_DESCR_Tag)
{
dwOffset_Temp += 13UL;
length = _mp4ReadDescr(dwStartAddr, &dwOffset_Temp, &tag);
if(tag == MP4_DEC_SPECIFIC_DESCR_Tag)
{
if(length > 128)
{
dbg_printf(("_mp4ReadBox_ESDS(): Too big size of the header data n"));
return FALSE;
}
pHeaderDataBuff = (BYTE*)malloc(length);
if(NULL == pHeaderDataBuff)
{
dbg_printf(("_mp4ReadBox_ESDS(): couldn't allocate memory for header data ...n"));
return FALSE;
}
if (FALSE == AuxCache_GetBytes(dwStartAddr, dwOffset_Temp, length, pHeaderDataBuff))
{
free(pHeaderDataBuff);
dbg_printf(("_mp4ReadBox_ESDS(): AuxCache_GetBytes() Fail[] n"));
return FALSE;
}
if(trackCodecType == CODEC_TYPE_VIDEO)
{
sc_SetBytes(SC_MPEG4_VIDEO_HEADER_DATA_ADDR,0,length,pHeaderDataBuff);
free(pHeaderDataBuff);
*len = length;
}
else if (trackCodecType == CODEC_TYPE_AUDIO)
{
#ifdef D_ENABLE_AAC_SUPPORT
if(FALSE == _mp4ReadAudioSpecificConfig(pHeaderDataBuff,length))
{
free(pHeaderDataBuff);
*len = 0;
dbg_printf(("_mp4ReadBox_ESDS(): couldn't parse AudioSpecificConfig headern"));
return FALSE;
}
else
#endif //D_ENABLE_AAC_SUPPORT
{
free(pHeaderDataBuff);
*len = length;
}
}
else if(trackCodecType == CODEC_TYPE_SUBPICTURE)
{
if(FALSE == _mp4ReadSubPictureConfig(pHeaderDataBuff,length))
{
free(pHeaderDataBuff);
*len = 0;
dbg_printf(("_mp4ReadBox_ESDS(): couldn't parse SubPictureSpecificConfig headern"));
return FALSE;
}
else
{
free(pHeaderDataBuff);
*len = length;
}
}
else
{
free(pHeaderDataBuff);
*len = 0;
}
}
}
}
return TRUE;
}
///////////////////////////////////////////////////////////////////////////
// Function name : _mp4StreamsInfoProcessing
// Purpose : Reads the 'moov' BOX.
// Input Parameters : dwStartAddr - The start address to get the BOX.
// dwStartOffset - The start offset to get the BOX.
// dwSize - The BOX' size.
// Return type : TRUE - if succeeded, FALSE otherwise.
///////////////////////////////////////////////////////////////////////////
static BOOL _mp4StreamsInfoProcessing(DWORD dwStartAddr, DWORD dwStartOffset, DWORD dwSize)
{
// UINT8 uiAudioStreamID[MAX_AUDS_PER_CLIP];
// UINT8 uiVideoStreamID;
// UINT8 uiSubtitleStreamID[MAX_SUB_PER_CLIP];
// UINT8 uiAudioCnt = 0,uiSubtitleCnt = 0;
DWORD dwOffset = dwStartOffset, dwOffsetTemp;
// MPEG4StreamHeadInfo videoStreamHeaderInfo, firstAudioStreamHeaderInfo;
// MPEG4VideoStreamInfoTemp *pVideoStreamInfoTemp;
// MPEG4AudioStreamInfoTemp *pAudioStreamInfoTemp;
MP4Box MP4BoxBuff;
BYTE TempBuff[10]; // version+flags
WORD wVersion;
// BOOL bGetNextBoxFalse = FALSE;
// BOOL bGetBytes = FALSE;
BOOL bError = FALSE;
// DWORD dwTrackID;
DWORD dwTrackTimeScale = 1;
BOOL bVideoTrackExist = FALSE;
BOOL bAudioTrackExist = FALSE;
BOOL bTrackValid = FALSE;
MP4_CODEC_TYPE trackCodecType;
WORD wNumOfMB;
DWORD dwEntryCount;
MP4StreamSampleTableAddrEX mp4StreamSampleTableAddrEX;
BYTE mp4StreamSampleTableFlag =0;
// DWORD dwSampleTableAddr = SAMPLE_TABLE_START_ADDR;
DWORD dwEndOffset = dwStartOffset + dwSize-8UL;
CHAR languageCode[3];
_dwMP4SampleTableAddr = SAMPLE_TABLE_START_ADDR;
_mpeg4SubtitleAvailableNum =0;
_mpeg4SubtitleInternalAvailableNum = 0;
_mpeg4AudioAvailableNum =0;
_mpeg4ChapterAvailableNum =0;
_mpeg4VideoStreamID = NO_STREAM;
_mpeg4AudioStreamID = NO_STREAM;
_mpeg4SubtitleStreamID = NO_STREAM;
trackCodecType = CODEC_TYPE_UNKNOWN;
_mpeg4VideoHeaderDataLength = 0;
_mpeg4VideoScale = 1;
_mpeg4VideoRate = 30;// supposed
_mpeg4VideoCodec = MP4V;
_dwMP4ChapterOffset = 0;
_dwMP4ChunkSizeEntryTotal = 0;
uiMP4ReservedNum = 0;
while (dwOffset < dwEndOffset)
{
if (FALSE == _mp4GetNextBox(dwStartAddr, &dwOffset, &MP4BoxBuff))
{
bError = TRUE;
dbg_printf(("_mp4StreamsInfoProcessing(): AuxCache_GetBytes() Fail[1] n"));
break;
}
if ((0 == strnicmp((LPSTR)(&MP4BoxBuff.ulType), MP4_TRACK_ID, FOURCC_FIELD_LENGTH)) ||
(0 == strnicmp((LPSTR)(&MP4BoxBuff.ulType), MP4_MEDIA_ID, FOURCC_FIELD_LENGTH)) ||
(0 == strnicmp((LPSTR)(&MP4BoxBuff.ulType), MP4_MEDIA_INFOMATION_ID, FOURCC_FIELD_LENGTH)) ||
(0 == strnicmp((LPSTR)(&MP4BoxBuff.ulType), MP4_SAMPLE_TABLE_ID, FOURCC_FIELD_LENGTH)) ||
(0 == strnicmp((LPSTR)(&MP4BoxBuff.ulType), MP4_USER_DATA_ID, FOURCC_FIELD_LENGTH)))
{
// container BOX
// dwOffset += 8UL;
}
else
{
dwOffsetTemp = dwOffset;
dwOffset += MP4BoxBuff.ulSize;
}
if (0 == strnicmp((LPSTR)(&MP4BoxBuff.ulType), MP4_TRACK_HEADER_ID, FOURCC_FIELD_LENGTH))
{
if(trackCodecType == CODEC_TYPE_VIDEO)
{
_mpeg4VideoRate = dwTrackTimeScale;
if ((mp4StreamSampleTableFlag & VIDEO_SAMPLETABLE_VALID) == VIDEO_SAMPLETABLE_VALID)
{
// mp4ChunkSizeStartAddr = dwSampleTableAddr;
// mp4SyncEntryStartAddr = MPEG4_PROCESSING_BUFF_ADDR;
sc_SetBytes(SC_MPEG4_VIDEO_SAMPLE_TABLE_ADDREX_BUFF_ADDR,0,SIZE_OF_MP4StreamSampleTableAddrEX,(BYTE*)&mp4StreamSampleTableAddrEX);
}
else
{
tr_printf(("Short of the video sample table!n"));
_mpeg4VideoStreamID = NO_STREAM;
_mpeg4VideoCodec = DIVX_UNKNOWN;
}
}
else if (trackCodecType == CODEC_TYPE_AUDIO)
{
_mpeg4AudioRate = dwTrackTimeScale;
memcpy(_mpeg4AudioLanguageCode,languageCode,3);
// store aduio stream info to DRAM
sc_SetBytes(SC_MPEG4_AUDIO_STREAM_INFO_ADDR,
((_mpeg4AudioAvailableNum-1) * SIZE_OF_AUDIO_STREAM_INFO),
SIZE_OF_AUDIO_STREAM_INFO,
(BYTE*)&_mpeg4AudioStreamInfo
);
if ((mp4StreamSampleTableFlag & AUDIO_SAMPLETABLE_VALID) == AUDIO_SAMPLETABLE_VALID)
{
sc_SetBytes(SC_MPEG4_AUDIO_SAMPLE_TABLE_ADDREX_BUFF_ADDR + ((_mpeg4AudioAvailableNum - 1) *SIZE_OF_MP4StreamSampleTableAddrEX_IN_DWORD),
0,SIZE_OF_MP4StreamSampleTableAddrEX,(BYTE*)&mp4StreamSampleTableAddrEX);
}
else
{
tr_printf(("Short of the audio sample table!n"));
_mpeg4AudioStreamID = NO_STREAM;
_mpeg4AudioCodec = AUDIO_UNKNOWN;
_mpeg4AudioAvailableNum --;
}
}
else if (trackCodecType == CODEC_TYPE_SUBPICTURE || trackCodecType == CODEC_TYPE_SUBTITLE)
{
_mpeg4SubtitleTimeScale = dwTrackTimeScale;
memcpy(_mpeg4SubtitleLanguageCode,languageCode,3);
sc_SetBytes(SC_MPEG4_SUBTITLE_STREAM_INFO_ADDR,
((_mpeg4SubtitleAvailableNum-1) * SIZE_OF_SUBTITLE_STREAM_INFO),
SIZE_OF_SUBTITLE_STREAM_INFO,
(BYTE*)&_mpeg4SubtitleStreamInfo
);
if ((mp4StreamSampleTableFlag & SUB_SAMPLETABLE_VALID) == SUB_SAMPLETABLE_VALID)
{
sc_SetBytes(SC_MPEG4_SUBTITLE_SAMPLE_TABLE_ADDREX_BUFF_ADDR + ((_mpeg4SubtitleAvailableNum - 1) * SIZE_OF_MP4StreamSampleTableAddrEX_IN_DWORD),
0,SIZE_OF_MP4StreamSampleTableAddrEX,(BYTE*)&mp4StreamSampleTableAddrEX);
}
else
{
tr_printf(("Short of the subtitle sample table!n"));
_mpeg4SubtitleStreamID = NO_STREAM;
// _mpeg4SubtitleType = INTERNAL_SUBP;
_mpeg4SubtitleAvailableNum --;
_mpeg4SubtitleInternalAvailableNum --;
}
}
else if (trackCodecType == CODEC_TYPE_RESERVED)
{
if (mp4STCOEntryCount != 0)
{
sc_SetBytes(SC_MPEG4_RESERVED_SAMPLE_TABLE_ADDREX_BUFF_ADDR + (uiMP4ReservedNum * SIZE_OF_MP4StreamSampleTableAddrEX_IN_DWORD),
0,SIZE_OF_MP4StreamSampleTableAddrEX,(BYTE*)&mp4StreamSampleTableAddrEX);
uiMP4ReservedNum ++;
}
}
trackCodecType = CODEC_TYPE_UNKNOWN;
// trak header, "tkhd"
if (FALSE == AuxCache_GetBytes(dwStartAddr, dwOffsetTemp, (WORD)4, &TempBuff[0]))
{
bError = TRUE;
dbg_printf(("_mp4StreamsInfoProcessing(): AuxCache_GetBytes() Fail[2] n"));
break;
}
dwOffsetTemp += 4UL;
wVersion = (WORD)TempBuff[0];
dwOffsetTemp += ((wVersion == 1) ? 16UL : 8UL);
// if (FALSE == AuxCache_GetBytes(dwStartAddr, dwOffsetTemp, (WORD)4, &TempBuff[0]))
// {
// bError = TRUE;
// dbg_printf(("_mp4StreamsInfoProcessing(): AuxCache_GetBytes() Fail[] n"));
// break;
// }
// dwTrackID = _toBe32(&TempBuff[0]);
dwOffsetTemp += ((wVersion == 1) ? 12UL : 8UL);
dwOffsetTemp += 52UL;
// if (FALSE == AuxCache_GetBytes(dwStartAddr, dwOffsetTemp, (WORD)8, &TempBuff[0]))
// {
// bError = TRUE;
// dbg_printf(("_mp4StreamsInfoProcessing(): AuxCache_GetBytes() Fail[] n"));
// break;
// }
bTrackValid = FALSE;
mp4StreamSampleTableFlag = 0;
}
else if (0 == strnicmp((LPSTR)(&MP4BoxBuff.ulType), MP4_MEDIA_HEADER_ID, FOURCC_FIELD_LENGTH))
{
// media header, overall information, "mdhd"
if (FALSE == AuxCache_GetBytes(dwStartAddr, dwOffsetTemp, (WORD)4, &TempBuff[0]))
{
bError = TRUE;
dbg_printf(("_mp4StreamsInfoProcessing(): AuxCache_GetBytes() Fail[3] n"));
break;
}
dwOffsetTemp += 4UL;
wVersion = (WORD)TempBuff[0];
dwOffsetTemp += ((wVersion == 1) ? 16UL : 8UL);
if (FALSE == AuxCache_GetBytes(dwStartAddr, dwOffsetTemp, (WORD)4, &TempBuff[0]))
{
bError = TRUE;
dbg_printf(("_mp4StreamsInfoProcessing(): AuxCache_GetBytes() Fail[4] n"));
break;
}
dwOffsetTemp += 4UL;
dwTrackTimeScale = _toBe32(&TempBuff[0]);
dwOffsetTemp += ((wVersion == 1) ? 8UL : 4UL);
if (FALSE == AuxCache_GetBytes(dwStartAddr, dwOffsetTemp, (WORD)2, &TempBuff[0]))
{
bError = TRUE;
dbg_printf(("_mp4StreamsInfoProcessing(): AuxCache_GetBytes() Fail[4] n"));
break;
}
languageCode[0] = (TempBuff[0] >> 2) + 0x40; // Upper case
languageCode[1] = (((TempBuff[0] & 0x3)<<3) + (TempBuff[1] >> 5)) + 0x60;
languageCode[2] = (TempBuff[1] & 0x1F) + 0x60;
if (!((languageCode[0] >= 0x41) && (languageCode[0] <= 0x5A) &&
(languageCode[1] >= 0x61) && (languageCode[1] <= 0x7A) &&
(languageCode[2] >= 0x61) && (languageCode[2] <= 0x7A))) // invalid
{
languageCode[0] = 0;
languageCode[1] = 0;
languageCode[2] = 0;
}
}
else if (0 == strnicmp((LPSTR)(&MP4BoxBuff.ulType), MP4_HANDLER_REFERENCE_ID, FOURCC_FIELD_LENGTH))
{
// handler reference, "hdlr"
dwOffsetTemp += 8UL;
if (FALSE == AuxCache_GetBytes(dwStartAddr, dwOffsetTemp, (WORD)4, &TempBuff[0]))
{
bError = TRUE;
dbg_printf(("_mp4StreamsInfoProcessing(): AuxCache_GetBytes() Fail[5] n"));
break;
}
if (0 == strnicmp((LPSTR)(&TempBuff[0]), MP4_VIDEO_TRACK_HANDLER_TYPE, FOURCC_FIELD_LENGTH))
{
// video stream
trackCodecType = CODEC_TYPE_VIDEO;
bTrackValid = TRUE;
}
else if (0 == strnicmp((LPSTR)(&TempBuff[0]), MP4_AUDIO_TRACK_HANDLER_TYPE, FOURCC_FIELD_LENGTH))
{
// audio stream
trackCodecType = CODEC_TYPE_AUDIO;
// _mpeg4AudioHeaderDataLength = 0;
bTrackValid = TRUE;
}
#if 1
else if (0 == strnicmp((LPSTR)(&TempBuff[0]), MP4_SUBPICTURE_TRACK_HANDLER_TYPE, FOURCC_FIELD_LENGTH))
{
// subpicture stream
trackCodecType = CODEC_TYPE_SUBPICTURE;
bTrackValid = TRUE;
_mpeg4SubtitleAvailableNum++;
_mpeg4SubtitleInternalAvailableNum ++;
_mpeg4SubtitleStreamID = _mpeg4AudioAvailableNum+_mpeg4SubtitleAvailableNum;
_mpeg4SubtitleType = INTERNAL_SUBP;
}
else if (0 == strnicmp((LPSTR)(&TempBuff[0]), MP4_SUBTITLE_TRACK_HANDLER_TYPE, FOURCC_FIELD_LENGTH))
{
// subtitle stream
#if 1
trackCodecType = CODEC_TYPE_SUBTITLE;
bTrackValid = TRUE;
_mpeg4SubtitleAvailableNum++;
_mpeg4SubtitleInternalAvailableNum ++;
_mpeg4SubtitleStreamID = _mpeg4AudioAvailableNum+_mpeg4SubtitleAvailableNum;
_mpeg4SubtitleType = INTERNAL_SUBT;
#endif
}
#endif
else if (0 == strnicmp((LPSTR)(&TempBuff[0]), MP4_ODSM_TRACK_HANDLE_TYPE, FOURCC_FIELD_LENGTH))
{
trackCodecType = CODEC_TYPE_RESERVED;
bTrackValid = TRUE;
}
else if (0 == strnicmp((LPSTR)(&TempBuff[0]), MP4_BIFS_TRACK_HANDLE_TYPE, FOURCC_FIELD_LENGTH))
{
trackCodecType = CODEC_TYPE_RESERVED;
bTrackValid = TRUE;
}
}
#ifdef MP4_DRM_SUPPORT
else if (0 == strnicmp((LPSTR)(&MP4BoxBuff.ulType), MP4_NERO_DRM_ID, FOURCC_FIELD_LENGTH))
{
UINT32 uiDRMVersion;
BOOL bDRMEnable;
// BOOL bDRMPlaybackOnPc;
BOOL bDRMPlaybackOnCe;
BOOL bDRAMEnableStreaming;
BOOL bPlayback;
if (FALSE == AuxCache_GetBytes(dwStartAddr, dwOffsetTemp, (WORD)7, &TempBuff[0]))
{
bError = TRUE;
dbg_printf(("_mp4StreamsInfoProcessing(): AuxCache_GetBytes() Fail[13] n"));
break;
}
uiDRMVersion = _toBe32(&TempBuff[0]);
bDRMEnable = ((TempBuff[4] & 0x80) != 0);
// bDRMPlaybackOnPc = ((TempBuff[5] & 0x80) != 0);
bDRMPlaybackOnCe = ((TempBuff[5] & 0x40) != 0);
bDRAMEnableStreaming = ((TempBuff[6] & 0x80) != 0);
if (FALSE == bDRMEnable)
bPlayback = TRUE;
else
{
if (1 != uiDRMVersion)
bPlayback = FALSE;
else
{
if ((TRUE == bDRMPlaybackOnCe) && (TRUE == bDRAMEnableStreaming))
bPlayback = TRUE;
else
bPlayback = FALSE;
}
}
if (FALSE == bPlayback)
{
bMP4DRMDisable = TRUE;
tr_printf(("Can't Playback this file becuase DRM disable. n"));
return FALSE;
}
}
else
#endif
if (0 == strnicmp((LPSTR)(&MP4BoxBuff.ulType), MP4_CHAPTER_LIST_ID, FOURCC_FIELD_LENGTH))
{
_dwMP4ChapterOffset = dwOffsetTemp;
}
else if (0 == strnicmp((LPSTR)(&MP4BoxBuff.ulType), MP4_SAMPLE_DESCRIPTION_ID, FOURCC_FIELD_LENGTH))
{
// sample description, "stsd"
// DWORD dwEntryCount;
DWORD dwSize;
int len;
dwOffsetTemp += 8UL;
// if (FALSE == AuxCache_GetBytes(dwStartAddr, dwOffsetTemp, (WORD)4, &TempBuff[0]))
// {
// bError = TRUE;
// dbg_printf(("_mp4StreamsInfoProcessing(): AuxCache_GetBytes() Fail[] n"));
// break;
// }
// dwEntryCount = _toBe32(&TempBuff[0]);
// while(dwEntryCount--)
// {
if (FALSE == _mp4GetNextBox(dwStartAddr, &dwOffsetTemp, &MP4BoxBuff))
{
bError = TRUE;
break;
}
dwSize = MP4BoxBuff.ulSize;
if(trackCodecType == CODEC_TYPE_VIDEO)
{
dwOffsetTemp += 24UL;
dwSize -= 24UL;
// _mpeg4VideoStreamID = (BYTE)(dwTrackID & 0xff);
_mpeg4VideoCodec = determineDivXVersion(0UL,MP4BoxBuff.ulType);
if (_mpeg4VideoCodec == DIVX_UNKNOWN)
{
trackCodecType = CODEC_TYPE_UNKNOWN;
return FALSE;
// continue;
}
_mpeg4VideoStreamID = 0;
bVideoTrackExist = TRUE;
// bTrackValid = TRUE;
if (FALSE == AuxCache_GetBytes(dwStartAddr, dwOffsetTemp, (WORD)4, &TempBuff[0]))
{
bError = TRUE;
dbg_printf(("_mp4StreamsInfoProcessing(): AuxCache_GetBytes() Fail[6] n"));
break;
}
_mpeg4VideoWidth = _toBe16(&TempBuff[0]);
_mpeg4VideoHeight = _toBe16(&TempBuff[2]);
wNumOfMB = ((_mpeg4VideoWidth + 15) / 16) * ((_mpeg4VideoHeight + 15) / 16);
if(wNumOfMB > 1620) // 720x576/256
{
bError = TRUE;
dbg_printf(("Too large image size! Width: %d, Height: %dn",_mpeg4VideoWidth,_mpeg4VideoHeight));
break;
}
if(_mpeg4VideoWidth > 720)
{
dbg_printf(("Too large image width! Playback with artifacts! Width: %d, Height: %ln",_mpeg4VideoWidth,_mpeg4VideoHeight));
}
dwOffsetTemp += 54UL;
dwSize -= 54UL;
while(dwSize >= 8)
{
if (FALSE == _mp4GetNextBox(dwStartAddr, &dwOffsetTemp, &MP4BoxBuff))
{
bError = TRUE;
break;
}
if (0 == strnicmp((LPSTR)(&MP4BoxBuff.ulType), MP4_ESDS_ID, FOURCC_FIELD_LENGTH))
{
len = 0;
if (FALSE == _mp4ReadBox_ESDS(dwStartAddr, dwOffsetTemp, trackCodecType,&len))
{
bError = TRUE;
break;
}
if(len != 0)
_mpeg4VideoHeaderDataLength = len+(len%2);
}
dwSize -= (MP4BoxBuff.ulSize + 8UL); // supposed 32-bits size and not "uuid" type
dwOffsetTemp += MP4BoxBuff.ulSize;
}
if(bError == TRUE )
break;
}
else if (trackCodecType == CODEC_TYPE_AUDIO)
{
WORD wBitsPerSample;
dwOffsetTemp += 16UL;
dwSize -= 16UL;
// _mpeg4AudioStreamID = (BYTE)(dwTrackID & 0xff);
_mpeg4AudioCodec = determineAudioCodec(MP4BoxBuff.ulType, 0 , TRUE);
if (AUDIO_UNKNOWN == _mpeg4AudioCodec)
{
trackCodecType = CODEC_TYPE_UNKNOWN;
continue;
}
// bTrackValid = TRUE;
bAudioTrackExist = TRUE;
_mpeg4AudioAvailableNum++;
_mpeg4AudioStreamID = _mpeg4AudioAvailableNum;
if (FALSE == AuxCache_GetBytes(dwStartAddr, dwOffsetTemp, (WORD)10, &TempBuff[0]))
{
bError = TRUE;
dbg_printf(("_mp4StreamsInfoProcessing(): AuxCache_GetBytes() Fail[7] n"));
break;
}
_mpeg4AudioChannels = _toBe16(&TempBuff[0]);
wBitsPerSample = _toBe16(&TempBuff[2]);
_mpeg4AudioSamplesPerSec = (DWORD)_toBe16(&TempBuff[8]); // max: 65535 ? RB_TBD
#ifdef D_ENABLE_ADPCM_SUPPORT
if(_mpeg4AudioCodec == PCM)
{
_mpeg4AudioBitsPerSample_ADPCM = (BYTE)(wBitsPerSample & 0xff);
// _mpeg4AudioChannels_ADPCM = (BYTE)(wChanels & 0xff);
}
else
#endif
if (_mpeg4AudioCodec == AAC)
{
dwOffsetTemp += 12UL;
dwSize -= 12UL;
while(dwSize >= 8)
{
if (FALSE == _mp4GetNextBox(dwStartAddr, &dwOffsetTemp, &MP4BoxBuff))
{
bError = TRUE;
break;
}
if (0 == strnicmp((LPSTR)(&MP4BoxBuff.ulType), MP4_ESDS_ID, FOURCC_FIELD_LENGTH))
{
len = 0;
if (FALSE == _mp4ReadBox_ESDS(dwStartAddr, dwOffsetTemp, trackCodecType,&len))
{
_mpeg4AudioCodec = AUDIO_UNKNOWN;
//bError = TRUE;
break;
}
// if(len != 0)
// _mpeg4AudioHeaderDataLength = len;
}
dwSize -= (MP4BoxBuff.ulSize + 8UL); // supposed 32-bits size and not "uuid" type
dwOffsetTemp += MP4BoxBuff.ulSize;
}
if(bError == TRUE )
break;
}
}
else if (trackCodecType == CODEC_TYPE_SUBPICTURE)
{
if (MP4BoxBuff.ulType != MKTAG('m', 'p', '4', 's'))
{
trackCodecType = CODEC_TYPE_UNKNOWN;
continue;
}
dwOffsetTemp += 8UL;
dwSize -= 8UL;
while(dwSize >= 8)
{
if (FALSE == _mp4GetNextBox(dwStartAddr, &dwOffsetTemp, &MP4BoxBuff))
{
bError = TRUE;
break;
}
if (0 == strnicmp((LPSTR)(&MP4BoxBuff.ulType), MP4_ESDS_ID, FOURCC_FIELD_LENGTH))
{
len = 0;
if (FALSE == _mp4ReadBox_ESDS(dwStartAddr, dwOffsetTemp, trackCodecType,&len))
{
bError = TRUE;
break;
}
}
dwSize -= (MP4BoxBuff.ulSize + 8UL); // supposed 32-bits size and not "uuid" type
dwOffsetTemp += MP4BoxBuff.ulSize;
}
}
if(bError == TRUE)
break;
}
else if (bTrackValid == FALSE)
{
// bypass
}
else if (0 == strnicmp((LPSTR)(&MP4BoxBuff.ulType), MP4_DECODING_TIME_TO_SAMPLE_ID, FOURCC_FIELD_LENGTH))
{
// Decoding Time to Sample, "stts"
DWORD dwSampleCount;
DWORD dwSampleDelta;
mp4StreamSampleTableFlag = mp4StreamSampleTableFlag | STTS;
dwOffsetTemp += 4UL;
if (FALSE == AuxCache_GetBytes(dwStartAddr, dwOffsetTemp, (WORD)4, &TempBuff[0]))
{
bError = TRUE;
dbg_printf(("_mp4StreamsInfoProcessing(): AuxCache_GetBytes() Fail[8] n"));
break;
}
dwEntryCount = _toBe32(&TempBuff[0]);
dwOffsetTemp += 4UL;
if((trackCodecType == CODEC_TYPE_VIDEO) || (trackCodecType == CODEC_TYPE_AUDIO))
{
if(dwEntryCount > 1 ) // supposed dwEntryCount =1 for video/audio, TBD for subtitle
{
DWORD dwEntrySize;
WORD wCacheSize;
DWORD dwDRAMAddr = _dwMP4SampleTableAddr;
WORD wCurrEntryCount;
WORD wOffset;
DWORD dwSampleCountSum = 0UL;
DWORD dwSampleDeltaSum = 0UL;
dbg_printf(("_mp4StreamsInfoProcessing(): dwEntryCount is greater than 1 n"));
// get the average value
#define MP4_STTS_ENTRY_STORE_MAX 100
dwEntryCount = MIN(dwEntryCount,MP4_STTS_ENTRY_STORE_MAX);
dwEntrySize = dwEntryCount * 2 * sizeof(DWORD);
// No used again, temporary store
if(FALSE == _mp4StoreSampleTable(dwStartAddr, dwOffsetTemp, dwEntrySize, _dwMP4SampleTableAddr, FALSE))
{
bError = TRUE;
dbg_printf(("_mp4StreamsInfoProcessing(): _mp4StoreSampleTable() Fail[11] n"));
break;
}
while(dwEntrySize > 0)
{
wCacheSize = (dwEntrySize < MAX_SAMPLE_TABLE_BUFFER_SIZE) ? (WORD)dwEntrySize : MAX_SAMPLE_TABLE_BUFFER_SIZE;
wai_sem(SEM_DRAM_ID);
I49_ReadDRAMData(dwDRAMAddr,(UINT16*)&_MP4SharedBuff[0], (wCacheSize/2));
sig_sem(SEM_DRAM_ID);
wCurrEntryCount = wCacheSize/8;
wOffset = 0;
while(wCurrEntryCount--)
{
// <<< Stivenz_0224_2005: Fix MP4 remain time error
memcpy(&dwSampleCount, &_MP4SharedBuff[8*wOffset], 4);
memcpy(&dwSampleDelta, &_MP4SharedBuff[(8*wOffset)+4], 4);
//dwSampleCount = _toBe32((DWORD*)&_MP4SharedBuff[8*wOffset]); // RB_TBD
//dwSampleDelta = _toBe32((BYTE*)&_MP4SharedBuff[(8*wOffset)+4]);
// >>> Stivenz_0224_2005: Fix MP4 remain time error
dwSampleCountSum += dwSampleCount;
dwSampleDeltaSum += (dwSampleCount*dwSampleDelta);
wOffset ++;
if (dwSampleCountSum > MP4_STTS_ENTRY_STORE_MAX)
break;
}
if (dwSampleCountSum > MP4_STTS_ENTRY_STORE_MAX)
break;
dwEntrySize -= wCacheSize;
}
dwSampleDelta = dwSampleDeltaSum/dwSampleCountSum;
}
else
{
if (FALSE == AuxCache_GetBytes(dwStartAddr, dwOffsetTemp, (WORD)8, &TempBuff[0]))
{
bError = TRUE;
dbg_printf(("_mp4StreamsInfoProcessing(): AuxCache_GetBytes() Fail[9] n"));
break;
}
dwSampleCount = _toBe32(&TempBuff[0]); // RB_TBD
dwSampleDelta = _toBe32(&TempBuff[4]);
}
}
else if (trackCodecType == CODEC_TYPE_SUBTITLE || trackCodecType == CODEC_TYPE_SUBPICTURE)
{
DWORD dwEntrySize;
mp4STTSOffsetInFile = dwOffsetTemp;
mp4STTSStartAddr = _dwMP4SampleTableAddr;
mp4STTSEntryCount = dwEntryCount;
dwEntrySize = dwEntryCount * sizeof(MP4TimeToSampleEntry);
#ifdef MP4_STORE_SAMPLETABLE_AFTER
dbg_printf((" STTS' offset: 0x%lx, Count: 0x%lx, Size: 0x%lxn", dwOffsetTemp, dwEntryCount, dwEntrySize));
#else
if(FALSE == _mp4StoreSampleTable(dwStartAddr, dwOffsetTemp, dwEntrySize, _dwMP4SampleTableAddr, FALSE))
{
bError = TRUE;
dbg_printf(("_mp4StreamsInfoProcessing(): _mp4StoreSampleTable() Fail[11] n"));
break;
}
dbg_printf(("=========================================================n"));
dbg_printf(("dwSampleTableAddr - stts : 0x%lx, Size: 0x%lxn",_dwMP4SampleTableAddr,(dwEntrySize>>1)));
dbg_printf(("=========================================================n"));
_dwMP4SampleTableAddr += (dwEntrySize>>1);
_dwMP4SampleTableAddr = ((_dwMP4SampleTableAddr>>9)+1)<<9;
#endif
}
if(trackCodecType == CODEC_TYPE_VIDEO)
{
// _mpeg4VideoLength = dwSampleCount;
_mpeg4VideoScale = dwSampleDelta;
}
else if (trackCodecType == CODEC_TYPE_AUDIO)
{
// _mpeg4AudioLength = dwSampleCount;
_mpeg4AudioScale = dwSampleDelta;
}
}
else if (0 == strnicmp((LPSTR)(&MP4BoxBuff.ulType), MP4_SAMPLE_TO_CHUNK_ID, FOURCC_FIELD_LENGTH))
{
// sampe to chunk, "stsc"
DWORD dwEntrySize;
dwOffsetTemp += 4UL;
if (FALSE == AuxCache_GetBytes(dwStartAddr, dwOffsetTemp, (WORD)4, &TempBuff[0]))
{
bError = TRUE;
dbg_printf(("_mp4StreamsInfoProcessing(): AuxCache_GetBytes() Fail[10] n"));
break;
}
dwEntryCount = _toBe32(&TempBuff[0]);
dwOffsetTemp += 4UL;
mp4StreamSampleTableFlag = mp4StreamSampleTableFlag | STSC;
mp4STSCOffsetInFile = dwOffsetTemp;
mp4STSCStartAddr = _dwMP4SampleTableAddr;
mp4STSCEntryCount = dwEntryCount;
dwEntrySize = dwEntryCount * sizeof(MP4SampleToChunkEntry);
#ifdef MP4_STORE_SAMPLETABLE_AFTER
dbg_printf((" STSC' offset: 0x%lx, Count: 0x%lx, Size: 0x%lxn", dwOffsetTemp, dwEntryCount, dwEntrySize));
#else
if(FALSE == _mp4StoreSampleTable(dwStartAddr, dwOffsetTemp, dwEntrySize, _dwMP4SampleTableAddr, FALSE))
{
bError = TRUE;
dbg_printf(("_mp4StreamsInfoProcessing(): _mp4StoreSampleTable() Fail[11] n"));
break;
}
dbg_printf(("=========================================================n"));
dbg_printf(("dwSampleTableAddr - stsc : 0x%lx, Size: 0x%lxn",_dwMP4SampleTableAddr,(dwEntrySize>>1)));
dbg_printf(("=========================================================n"));
_dwMP4SampleTableAddr += (dwEntrySize>>1);
_dwMP4SampleTableAddr = ((_dwMP4SampleTableAddr>>9)+1)<<9;
#endif
}
else if ((0 == strnicmp((LPSTR)(&MP4BoxBuff.ulType), MP4_SAMPLE_SIZE_ID, FOURCC_FIELD_LENGTH)) ||
(0 == strnicmp((LPSTR)(&MP4BoxBuff.ulType), MP4_COMPACT_SAMPLE_SIZE_ID, FOURCC_FIELD_LENGTH)))
{
// Sample Size "stsz" or Compact Sample Size "stz2"
mp4CompactSampeSize = FALSE;
if (0 == strnicmp((LPSTR)(&MP4BoxBuff.ulType), MP4_COMPACT_SAMPLE_SIZE_ID, FOURCC_FIELD_LENGTH))
mp4CompactSampeSize = TRUE;
dwOffsetTemp += 4UL;
if (FALSE == AuxCache_GetBytes(dwStartAddr, dwOffsetTemp, (WORD)8, &TempBuff[0]))
{
bError = TRUE;
dbg_printf(("_mp4StreamsInfoProcessing(): AuxCache_GetBytes() Fail[12 n"));
break;
}
mp4STSZSampleSize = _toBe32(&TempBuff[0]);
mp4STSZEntryCount = _toBe32(&TempBuff[4]);
if(trackCodecType == CODEC_TYPE_VIDEO)
{
_mpeg4VideoLength = mp4STSZEntryCount;
}
else if (trackCodecType == CODEC_TYPE_AUDIO)
{
_mpeg4AudioLength = mp4STSZEntryCount;
}
mp4STSZOffsetInFile = (dwOffsetTemp+8UL);
mp4StreamSampleTableFlag = mp4StreamSampleTableFlag | STSZ;
}
else if ((0 == strnicmp((LPSTR)(&MP4BoxBuff.ulType), MP4_CHUNK_OFFSET_ID, FOURCC_FIELD_LENGTH)) ||
(0 == strnicmp((LPSTR)(&MP4BoxBuff.ulType), MP4_64BIT_CHUNK_OFFSET_ID, FOURCC_FIELD_LENGTH)))
{
// Chunk Offset "stco" or 64bits Chunk Offset "co64"
DWORD dwEntrySize;
mp4CO64 = FALSE;
if (0 == strnicmp((LPSTR)(&MP4BoxBuff.ulType), MP4_64BIT_CHUNK_OFFSET_ID, FOURCC_FIELD_LENGTH))
mp4CO64 = TRUE;
dwOffsetTemp += 4UL;
if (FALSE == AuxCache_GetBytes(dwStartAddr, dwOffsetTemp, (WORD)4, &TempBuff[0]))
{
bError = TRUE;
dbg_printf(("_mp4StreamsInfoProcessing(): AuxCache_GetBytes() Fail[13] n"));
break;
}
dwEntryCount = _toBe32(&TempBuff[0]);
dwOffsetTemp += 4UL;
mp4STCOOffsetInFile = dwOffsetTemp;
mp4STCOStartAddr = _dwMP4SampleTableAddr;
mp4STCOEntryCount = dwEntryCount;
if (dwEntryCount != 0UL) // patch from illegal stream
mp4StreamSampleTableFlag = mp4StreamSampleTableFlag | STCO;
else
tr_printf(("This track's stco entry count is 0, invalid!n"));
_dwMP4ChunkSizeEntryTotal += dwEntryCount;
dwEntrySize = dwEntryCount * sizeof(DWORD) * (mp4CO64 ? 2 : 1);
#ifdef MP4_STORE_SAMPLETABLE_AFTER
dbg_printf((" STCO' offset: 0x%lx, Count: 0x%lx, Size: 0x%lxn", dwOffsetTemp, dwEntryCount, dwEntrySize));
#else
if(FALSE == _mp4StoreSampleTable(dwStartAddr, dwOffsetTemp, dwEntrySize, _dwMP4SampleTableAddr, mp4CO64))
{
bError = TRUE;
dbg_printf(("_mp4StreamsInfoProcessing(): _mp4StoreSampleTable() Fail[14] n"));
break;
}
dbg_printf(("=========================================================n"));
dbg_printf(("dwSampleTableAddr - stco : 0x%lx, Size: 0x%lxn",_dwMP4SampleTableAddr,((dwEntryCount * sizeof(DWORD))>>1)));
dbg_printf(("=========================================================n"));
_dwMP4SampleTableAddr += ((dwEntryCount * sizeof(DWORD))>>1);
_dwMP4SampleTableAddr = ((_dwMP4SampleTableAddr>>9)+1)<<9;
#endif
}
else if ((0 == strnicmp((LPSTR)(&MP4BoxBuff.ulType), MP4_SYNC_SAMPLE_ID, FOURCC_FIELD_LENGTH)) &&
(trackCodecType == CODEC_TYPE_VIDEO)) // only store video track "stss"
{
// Sync Sample, "stss"
DWORD dwEntrySize;
dwOffsetTemp += 4UL;
if (FALSE == AuxCache_GetBytes(dwStartAddr, dwOffsetTemp, (WORD)4, &TempBuff[0]))
{
bError = TRUE;
dbg_printf(("_mp4StreamsInfoProcessing(): AuxCache_GetBytes() Fail[15] n"));
break;
}
dwEntryCount = _toBe32(&TempBuff[0]);
dwOffsetTemp += 4UL;
mp4STSSOffsetInFile = dwOffsetTemp;
mp4STSSStartAdd = _dwMP4SampleTableAddr;
mp4STSSEntryCount = dwEntryCount;
if (mp4STSSEntryCount >= 0x10000UL) // RB_TBD
{
_uiMPEG4NextIndexEntry = 0xFFFF;
tr_printf(("WARNING: MP4 Sync Sample is more than 65535 n"));
}
else
{
_uiMPEG4NextIndexEntry = (UINT16)(mp4STSSEntryCount & 0xFFFFUL);
}
mp4StreamSampleTableFlag = mp4StreamSampleTableFlag | STSS;
dwEntrySize = dwEntryCount * sizeof(DWORD);
#ifdef MP4_STORE_SAMPLETABLE_AFTER
dbg_printf((" STTS' offset: 0x%lx, Count: 0x%lx, Size: 0x%lxn", dwOffsetTemp, dwEntryCount, dwEntrySize));
#else
if(FALSE == _mp4StoreSampleTable(dwStartAddr, dwOffsetTemp, dwEntrySize, _dwMP4SampleTableAddr, FALSE))
{
bError = TRUE;
dbg_printf(("_mp4StreamsInfoProcessing(): _mp4StoreSampleTable() Fail[16] n"));
break;
}
dbg_printf(("=========================================================n"));
dbg_printf(("dwSampleTableAddr - stss : 0x%lx, Size: 0x%lxn",_dwMP4SampleTableAddr,(dwEntrySize>>1)));
dbg_printf(("=========================================================n"));
_dwMP4SampleTableAddr += (dwEntrySize>>1);
_dwMP4SampleTableAddr = ((_dwMP4SampleTableAddr>>9)+1)<<9;
#endif
}
if(bError == TRUE)
break;
}
if(trackCodecType == CODEC_TYPE_VIDEO)
{
_mpeg4VideoRate = dwTrackTimeScale;
if ((mp4StreamSampleTableFlag & VIDEO_SAMPLETABLE_VALID) == VIDEO_SAMPLETABLE_VALID)
{
sc_SetBytes(SC_MPEG4_VIDEO_SAMPLE_TABLE_ADDREX_BUFF_ADDR,0,SIZE_OF_MP4StreamSampleTableAddrEX,(BYTE*)&mp4StreamSampleTableAddrEX);
}
else
{
tr_printf(("Short of the video sample table!n"));
_mpeg4VideoStreamID = NO_STREAM;
_mpeg4VideoCodec = DIVX_UNKNOWN;
}
}
else if (trackCodecType == CODEC_TYPE_AUDIO)
{
_mpeg4AudioRate = dwTrackTimeScale;
memcpy(_mpeg4AudioLanguageCode,languageCode,3);
// store aduio stream info to DRAM
sc_SetBytes(SC_MPEG4_AUDIO_STREAM_INFO_ADDR,
((_mpeg4AudioAvailableNum-1) * SIZE_OF_AUDIO_STREAM_INFO),
SIZE_OF_AUDIO_STREAM_INFO,
(BYTE*)&_mpeg4AudioStreamInfo
);
if ((mp4StreamSampleTableFlag & AUDIO_SAMPLETABLE_VALID) == AUDIO_SAMPLETABLE_VALID)
{
sc_SetBytes(SC_MPEG4_AUDIO_SAMPLE_TABLE_ADDREX_BUFF_ADDR + ((_mpeg4AudioAvailableNum - 1) *SIZE_OF_MP4StreamSampleTableAddrEX_IN_DWORD),
0,SIZE_OF_MP4StreamSampleTableAddrEX,(BYTE*)&mp4StreamSampleTableAddrEX);
}
else
{
tr_printf(("Short of the audio sample table!n"));
_mpeg4AudioStreamID = NO_STREAM;
_mpeg4AudioCodec = AUDIO_UNKNOWN;
_mpeg4AudioAvailableNum --;
}
}
else if (trackCodecType == CODEC_TYPE_SUBPICTURE || trackCodecType == CODEC_TYPE_SUBTITLE)
{
_mpeg4SubtitleTimeScale = dwTrackTimeScale;
memcpy(_mpeg4SubtitleLanguageCode,languageCode,3);
sc_SetBytes(SC_MPEG4_SUBTITLE_STREAM_INFO_ADDR,
((_mpeg4SubtitleAvailableNum-1) * SIZE_OF_SUBTITLE_STREAM_INFO),
SIZE_OF_SUBTITLE_STREAM_INFO,
(BYTE*)&_mpeg4SubtitleStreamInfo
);
if ((mp4StreamSampleTableFlag & SUB_SAMPLETABLE_VALID) == SUB_SAMPLETABLE_VALID)
{
sc_SetBytes(SC_MPEG4_SUBTITLE_SAMPLE_TABLE_ADDREX_BUFF_ADDR + ((_mpeg4SubtitleAvailableNum - 1) * SIZE_OF_MP4StreamSampleTableAddrEX_IN_DWORD),
0,SIZE_OF_MP4StreamSampleTableAddrEX,(BYTE*)&mp4StreamSampleTableAddrEX);
}
else
{
tr_printf(("Short of the subtitle sample table!n"));
_mpeg4SubtitleStreamID = NO_STREAM;
// _mpeg4SubtitleType = INTERNAL_SUBP;
_mpeg4SubtitleAvailableNum --;
_mpeg4SubtitleInternalAvailableNum --;
}
}
else if (trackCodecType == CODEC_TYPE_RESERVED)
{
if (mp4STCOEntryCount != 0)
{
sc_SetBytes(SC_MPEG4_RESERVED_SAMPLE_TABLE_ADDREX_BUFF_ADDR + (uiMP4ReservedNum * SIZE_OF_MP4StreamSampleTableAddrEX_IN_DWORD),
0,SIZE_OF_MP4StreamSampleTableAddrEX,(BYTE*)&mp4StreamSampleTableAddrEX);
uiMP4ReservedNum ++;
}
}
if(TRUE == bError)
{
tr_printf(("FATAL: _mp4StreamsInfoProcessing() Failed n"));
return FALSE;
}
else
{
if (FALSE == bAudioTrackExist)
tr_printf(("No found the audio stream n"));
else if (FALSE == bVideoTrackExist)
tr_printf(("No found the video stream n"));
return TRUE;
}
}
///////////////////////////////////////////////////////////////////////////
// Function name : _mp4InfoProcessing
// Purpose : Reads all the needed data from the MP4 file header.
// Input Parameters : dwClipStartAddr - The start address of the ASF file.
// Return type : TRUE - if succeeded, FALSE otherwise.
// Description : The function reads all the data needed for managing
// of the playback including parameters needed by the
// DVP.
///////////////////////////////////////////////////////////////////////////
static BOOL _mp4InfoProcessing(DWORD dwClipStartAddr, ULONG cbFileSize)
{
DWORD dwOffset = 0UL;
BOOL bMP4File = FALSE;
MP4Box MP4BoxBuff;
BOOL bMediaFound = FALSE;
if (_bMPEG4IsIndexProcessed == TRUE)
return TRUE;
dbg_printf(("Aquiring MP4 file info...n"));
_bMP4IsNeroDigital = FALSE;
bMP4UnSupportProfile = FALSE;
bMP4DRMDisable = FALSE;
/* Verifying that the .MP4 file is an MP4 one */
while (dwOffset <= (cbFileSize-8UL))
{
if (FALSE == _mp4GetNextBox(dwClipStartAddr, &dwOffset, &MP4BoxBuff))
{
dbg_printf(("FATAL: _mp4InfoProcessing() Failed [1]n"));
return FALSE;
}
if (0 == strnicmp((LPSTR)(&MP4BoxBuff.ulType), MP4_FILE_TYPE_ID, FOURCC_FIELD_LENGTH))
{
bMP4File = TRUE;
break;
}
dwOffset += MP4BoxBuff.ulSize;
}
// found Nero Digital FourCC code
{
DWORD dwOffsetTemp = dwOffset + 8UL; // major_band and minor_version
UINT32 ulCompatibleBrandsSize;
BYTE TempBuff[4];
ulCompatibleBrandsSize = (MP4BoxBuff.ulSize - 8UL)/4;
while (ulCompatibleBrandsSize--)
{
if (FALSE == AuxCache_GetBytes(dwClipStartAddr, dwOffsetTemp, (WORD)4, &TempBuff[0]))
{
dbg_printf(("_mp4InfoProcessing(): AuxCache_GetBytes() Fail[1] n"));
break;
}
dwOffsetTemp += 4UL;
if ((0 == strnicmp((LPSTR)(&TempBuff[0]), NERO_DIGITAL_MOBIE, FOURCC_FIELD_LENGTH)) ||
(0 == strnicmp((LPSTR)(&TempBuff[0]), NERO_DIGITAL_PORTABLE, FOURCC_FIELD_LENGTH)) ||
(0 == strnicmp((LPSTR)(&TempBuff[0]), NERO_DIGITAL_STANDARD, FOURCC_FIELD_LENGTH)) ||
(0 == strnicmp((LPSTR)(&TempBuff[0]), NERO_DIGITAL_CINEMA, FOURCC_FIELD_LENGTH)) ||
(0 == strnicmp((LPSTR)(&TempBuff[0]), NERO_DIGITAL_HDTV, FOURCC_FIELD_LENGTH)))
{
_bMP4IsNeroDigital = TRUE;
break;
}
else if ((0 == strnicmp((LPSTR)(&TempBuff[0]), NERO_DIGITAL_MOBIE_AVC, FOURCC_FIELD_LENGTH)) ||
(0 == strnicmp((LPSTR)(&TempBuff[0]), NERO_DIGITAL_PORTABLE_AVC, FOURCC_FIELD_LENGTH)) ||
(0 == strnicmp((LPSTR)(&TempBuff[0]), NERO_DIGITAL_STANDARD_AVC, FOURCC_FIELD_LENGTH)) ||
(0 == strnicmp((LPSTR)(&TempBuff[0]), NERO_DIGITAL_CINEMA_AVC, FOURCC_FIELD_LENGTH)) ||
(0 == strnicmp((LPSTR)(&TempBuff[0]), NERO_DIGITAL_HDTV_AVC, FOURCC_FIELD_LENGTH)))
{
bMP4UnSupportProfile = TRUE;
return FALSE;
}
}
}
if (FALSE == bMP4File)
{
tr_printf(("FATAL: MP4 Header was not detectedn"));
return FALSE;
}
/* Reading the MP4 file header */
dwOffset = 0UL;
while (dwOffset < (cbFileSize-8UL))
{
if (FALSE == _mp4GetNextBox(dwClipStartAddr, &dwOffset, &MP4BoxBuff))
{
dbg_printf(("FATAL: _mp4InfoProcessing() Failed [2]n"));
return FALSE;
}
if (0 == strnicmp((LPSTR)(&MP4BoxBuff.ulType), MP4_MOVIE_ID, FOURCC_FIELD_LENGTH))
{
// meda-data
if(FALSE == _mp4StreamsInfoProcessing(dwClipStartAddr,dwOffset, MP4BoxBuff.ulSize))
{
dbg_printf(("FATAL: _mp4InfoProcessing() Failed [3]n"));
return FALSE;
}
bMediaFound = TRUE;
}
else if (0 == strnicmp((LPSTR)(&MP4BoxBuff.ulType), MP4_MEDIA_DATA_ID, FOURCC_FIELD_LENGTH))
{
// media data
#ifdef MP4_NO_DUMMY_CHUNK
_dwMP4LastChunkEndOffset = dwOffset + MP4BoxBuff.ulSize;
#endif
}
dwOffset += MP4BoxBuff.ulSize;
}
return bMediaFound;
}
///////////////////////////////////////////////////////////////////////////
// Function name : _mp4VideoSampleTableProcessing
// Purpose : MP4 Video Sample Table Processing to get the Index Table and Chunk Size Table.
// Input Parameters : dwStartAddr - The start address to get the BOX.
// Return type : TRUE - if succeeded, FALSE otherwise.
///////////////////////////////////////////////////////////////////////////
static BOOL _mp4StreamSampleTableProcessing(DWORD dwStartAddr, WORD wSampleTableAddrEXAddr, DWORD *dwChunkSizeAddr, DWORD *dwSyncSampleAddr,
MP4_CODEC_TYPE codecType, DWORD dwMP4VideoSTSSStartAdd)
{
DWORD dwCurrentSampleSize;
DWORD dwCurrentSampleNumber;
DWORD dwCacheSampleNumberBound = 0UL, dwLastCacheSampleNumberBound = 0UL;
WORD wCacheSize;
BYTE fieldSizeInBytes;
DWORD dwSampleNumberPerChunk, dwChunkNumber = 0UL, dwChunkNumberBound = 0UL;
DWORD dwFirstSampleNumberOfChunk = 0UL;
DWORD dwChunkSize = 0UL, dwChunkOffset;
DWORD dwSyncSampleNumber = 0UL;
DWORD dwSyncNumber = 0UL;
// DWORD dwSTSCOffset, dwSTSCEntryCount;
BOOL bFirstTime = TRUE;
MP4StreamSampleTableAddrEX mp4StreamSampleTableAddrEX;
#ifdef MP4_PACK_STSC
DWORD dwPackSTSC;
#endif
MP4SampleToChunkEntry mp4SampleToChunkEntry;
DWORD mp4ChunkOffsetBuff[MP4_CHUNK_OFFSET_BUFF_SIZE];
#ifndef MP4_NO_DUMMY_CHUNK
#if 0
DWORD mp4ChunkSizeBuff[MP4_CHUNK_SIZE_BUFF_SIZE][2];
#else
DWORD mp4ChunkSizeBuff[MP4_CHUNK_SIZE_BUFF_SIZE];
#endif
#endif
DWORD mp4SyncSampleBuff[MP4_SYNC_SAMPLE_BUFF_SIZE];
MP4VideoSyncEntry mp4VideoSyncEntry[MP4_SYNC_ENTRY_BUFF_SIZE];
MP4AudioSyncEntry mp4AudioSyncEntry[MP4_SYNC_ENTRY_BUFF_SIZE];
DWORD dwAudioSkip;
DWORD dwAudioSkipRemider100;
DWORD dwAudioSkipRemider10000;
DWORD dwVideoSkip;
DWORD dwVideoSkipRemider100;
DWORD dwVideoSkipRemider10000;
DWORD dwSyncTime = 0UL;
DWORD dwAudioTime = 0UL;
WORD wAudioOnlySyncTime = 0; // in second
DWORD dwSampleTableStartAddr;
DWORD dwSampleTableOffset;
DWORD dwSampleTableSize;
DWORD dwVideoSTSSStartAdd = dwMP4VideoSTSSStartAdd;
MP4TimeToSampleEntry mp4TimeToSampleEntry;
MP4SubtitleSampleEntry mp4SubtitleSampleEntry[MP4_SUBTITLE_SAMPLE_ENTRY_BUFF_SIZE];
DWORD dwSampleCount = 0;
DWORD dwSampleTimeDelta;
DWORD dwCurrentSampleTime = 0;
DWORD dwCurrentSampleReminder = 0;
DWORD dwCurrentSampleTimeDelta;
DWORD dwCurrentSampleTime10, dwCurrentSampleTime1000;
DWORD dwPrevSampleTime1000 = 0;
DWORD dwSTCOAddr, dwSTSCCount, dwSTSCAddr;
#ifdef MP4_PACK_STCO
DWORD dwPreChunkOffset;
BOOL bPackSTCO;
#endif
sc_GetBytes(wSampleTableAddrEXAddr,0,SIZE_OF_MP4StreamSampleTableAddrEX,(BYTE*)&mp4StreamSampleTableAddrEX);
dwSTCOAddr = mp4STCOStartAddr;
dwSTSCCount = mp4STSCEntryCount;
dwSTSCAddr = mp4STSCStartAddr;
#ifdef MP4_PACK_STCO
bPackSTCO = mp4PackSTCO;
#endif
if(mp4CompactSampeSize)
fieldSizeInBytes = (BYTE)((mp4STSZSampleSize>>3) & 0xff);
else
fieldSizeInBytes = (BYTE)4;
if (fieldSizeInBytes == 0)
{
tr_printf(("Not support the stz2 field size is 4 n"));
return FALSE;
}
if (codecType == CODEC_TYPE_AUDIO)
{
UINT32 ulDelta;
dbg_printf(("The difference of A/V sync is %d msn", ((1000UL * _mpeg4AudioScale) / _mpeg4AudioRate)));
dwAudioSkip = (10000UL * _mpeg4AudioScale) / _mpeg4AudioRate;
ulDelta = (10000UL * _mpeg4AudioScale) - (dwAudioSkip * _mpeg4AudioRate);
ulDelta = (10000UL *ulDelta) / _mpeg4AudioRate;
dwAudioSkipRemider100 = ulDelta / 100;
dwAudioSkipRemider10000 = ulDelta % 100;
if (_mpeg4VideoStreamID != NO_STREAM)
{
dwVideoSkip = (10000UL * _mpeg4VideoScale) / _mpeg4VideoRate;
ulDelta = (10000UL * _mpeg4VideoScale) - (dwVideoSkip * _mpeg4VideoRate);
ulDelta = (10000UL *ulDelta) / _mpeg4VideoRate;
dwVideoSkipRemider100 = ulDelta / 100;
dwVideoSkipRemider10000 = ulDelta % 100;
}
#ifdef D_ENABLE_AAC_SUPPORT
if (_mpeg4AudioCodec == AAC)
_mpeg4AudioInfo_AAC.maxBlockSize = 0;
#endif
}
dwSampleTableStartAddr = dwStartAddr + (mp4STSZOffsetInFile/2048UL);
dwSampleTableOffset = mp4STSZOffsetInFile%2048UL;
dwSampleTableSize = mp4STSZEntryCount * fieldSizeInBytes;
dwSampleTableSize += dwSampleTableOffset;
for(dwCurrentSampleNumber=0UL; dwCurrentSampleNumber<=mp4STSZEntryCount; dwCurrentSampleNumber++)
{
// get the smple number per chunk, from "stsc"
#ifdef MP4_PACK_STSC
if (TRUE == mp4PackSTSC)
{
if (TRUE == bFirstTime)
{
wai_sem(SEM_DRAM_ID);
I49_ReadDRAMData(dwSTSCAddr,(UINT16*)&dwPackSTSC, (sizeof(DWORD)/2));
sig_sem(SEM_DRAM_ID);
dwSampleNumberPerChunk = dwPackSTSC & 0xFFFUL;
dwSTSCCount--;
if (dwSTSCCount > 0UL)
{
dwSTSCAddr += (sizeof(DWORD)/2);
wai_sem(SEM_DRAM_ID);
I49_ReadDRAMData(dwSTSCAddr,(UINT16*)&dwPackSTSC, (sizeof(DWORD)/2));
sig_sem(SEM_DRAM_ID);
dwChunkNumberBound = (dwPackSTSC>>12) -1;
dwSTSCCount--;
}
else
{
dwChunkNumberBound = 0xFFFFFFFFUL;
}
}
else if (dwChunkNumber >= dwChunkNumberBound)
{
dwSampleNumberPerChunk = dwPackSTSC & 0xFFFUL;
if (dwSTSCCount > 0UL)
{
dwSTSCAddr += (sizeof(DWORD)/2);
wai_sem(SEM_DRAM_ID);
I49_ReadDRAMData(dwSTSCAddr,(UINT16*)&dwPackSTSC, (sizeof(DWORD)/2));
sig_sem(SEM_DRAM_ID);
dwChunkNumberBound = (dwPackSTSC>>12)-1;
dwSTSCCount --;
}
else
{
dwChunkNumberBound = 0xFFFFFFFFUL;
}
}
}
else
#endif
{
if (TRUE == bFirstTime)
{
wai_sem(SEM_DRAM_ID);
I49_ReadDRAMData(dwSTSCAddr,(UINT16*)&mp4SampleToChunkEntry, (sizeof(MP4SampleToChunkEntry)/2));
sig_sem(SEM_DRAM_ID);
dwSampleNumberPerChunk = mp4SampleToChunkEntry.dwSamplePerChunk;//_toBe32((BYTE*)&mp4SampleToChunkEntry.dwSamplePerChunk);
dwSTSCCount--;
if (dwSTSCCount > 0UL)
{
dwSTSCAddr += (sizeof(MP4SampleToChunkEntry)/2);
wai_sem(SEM_DRAM_ID);
I49_ReadDRAMData(dwSTSCAddr,(UINT16*)&mp4SampleToChunkEntry, (sizeof(MP4SampleToChunkEntry)/2));
sig_sem(SEM_DRAM_ID);
dwChunkNumberBound = mp4SampleToChunkEntry.dwFirstChunk - 1; //_toBe32((BYTE*)&mp4SampleToChunkEntry.dwFirstChunk)-1;
dwSTSCCount--;
}
else
{
dwChunkNumberBound = 0xFFFFFFFFUL;
}
}
else if (dwChunkNumber >= dwChunkNumberBound)
{
dwSampleNumberPerChunk = mp4SampleToChunkEntry.dwSamplePerChunk; //_toBe32((BYTE*)&mp4SampleToChunkEntry.dwSamplePerChunk);
if (dwSTSCCount > 0UL)
{
dwSTSCAddr += (sizeof(MP4SampleToChunkEntry)/2);
wai_sem(SEM_DRAM_ID);
I49_ReadDRAMData(dwSTSCAddr,(UINT16*)&mp4SampleToChunkEntry, (sizeof(MP4SampleToChunkEntry)/2));
sig_sem(SEM_DRAM_ID);
dwChunkNumberBound = mp4SampleToChunkEntry.dwFirstChunk- 1;//_toBe32((BYTE*)&mp4SampleToChunkEntry.dwFirstChunk)-1;
dwSTSCCount --;
}
else
{
dwChunkNumberBound = 0xFFFFFFFFUL;
}
}
}
// get the current sample size, from "stsz"
if ((FALSE == mp4CompactSampeSize) &&(mp4STSZSampleSize != 0))
dwCurrentSampleSize = mp4STSZSampleSize;
else if (dwCurrentSampleNumber >= mp4STSZEntryCount)
dwCurrentSampleSize = 0UL;
else
{
if ((TRUE == bFirstTime) || (dwCurrentSampleNumber >= dwCacheSampleNumberBound))
{
DWORD dwLeftSampleSize = (mp4STSZEntryCount-dwCurrentSampleNumber)*fieldSizeInBytes;
DWORD dwOffset = dwSampleTableOffset + (dwCurrentSampleNumber * fieldSizeInBytes);
wCacheSize = (WORD)min(dwLeftSampleSize, MAX_SAMPLE_TABLE_BUFFER_SIZE);
#ifdef SUPPORT_FLASH_CARD
if(IS_PLAYING_CARD)
{
if (!AuxCache_GetBytes(dwSampleTableStartAddr, dwOffset, wCacheSize, (BYTE*)&_MP4SharedBuff[0]))
{
dbg_printf(("_mp4VideoSampleTableProcessing(): AuxCache_GetBytes() Fail[] n"));
break;
}
}
else
#endif
if (!AuxCache_GetFile(dwSampleTableStartAddr, dwOffset, wCacheSize, dwSampleTableSize, bFirstTime, (BYTE*)&_MP4SharedBuff[0]))
{
dbg_printf(("_mp4VideoSampleTableProcessing(): AuxCache_GetFile() Fail[] n"));
return FALSE;
}
dwLastCacheSampleNumberBound = dwCacheSampleNumberBound;
dwCacheSampleNumberBound += (wCacheSize/fieldSizeInBytes);
}
if (fieldSizeInBytes == 4)
dwCurrentSampleSize = _toBe32((BYTE*)&_MP4SharedBuff[4*(INT16)(dwCurrentSampleNumber - dwLastCacheSampleNumberBound)]);
else if (fieldSizeInBytes == 2)
dwCurrentSampleSize = _toBe16((BYTE*)&_MP4SharedBuff[2*(INT16)(dwCurrentSampleNumber - dwLastCacheSampleNumberBound)]);
else if (fieldSizeInBytes == 1)
dwCurrentSampleSize = _MP4SharedBuff[(INT16)(dwCurrentSampleNumber - dwLastCacheSampleNumberBound)];
}
#ifdef D_ENABLE_AAC_SUPPORT
if ((codecType == CODEC_TYPE_AUDIO) && (_mpeg4AudioCodec == AAC))
if(dwCurrentSampleSize > (DWORD)(_mpeg4AudioInfo_AAC.maxBlockSize))
_mpeg4AudioInfo_AAC.maxBlockSize =(UINT16) (dwCurrentSampleSize & 0xFFFF);
#endif
dwChunkSize += dwCurrentSampleSize;
// get the chunk offset, from "stco"
if (TRUE == bFirstTime)
{
#ifdef MP4_PACK_STCO
if (TRUE == bPackSTCO)
{
wai_sem(SEM_DRAM_ID);
I49_ReadDRAMData(dwSTCOAddr,(UINT16*)&dwPreChunkOffset, (sizeof(DWORD)/2));
sig_sem(SEM_DRAM_ID);
dwSTCOAddr += (sizeof(DWORD)/2);
}
#endif
if ((dwChunkNumber % MP4_CHUNK_OFFSET_BUFF_SIZE) == 0)
{
#ifdef MP4_PACK_STCO
if (TRUE == bPackSTCO)
{
_mp4LoadSTCOTable(dwSTCOAddr,mp4ChunkOffsetBuff,&dwPreChunkOffset);
dwSTCOAddr += MP4_PACK_STCO_BUFF_SIZE_IN_WORD;
}
else
#endif
{
wai_sem(SEM_DRAM_ID);
I49_ReadDRAMData(dwSTCOAddr,(UINT16*)&mp4ChunkOffsetBuff, ((MP4_CHUNK_OFFSET_BUFF_SIZE*sizeof(DWORD))/2));
sig_sem(SEM_DRAM_ID);
dwSTCOAddr += ((MP4_CHUNK_OFFSET_BUFF_SIZE*sizeof(DWORD))/2);
}
}
dwChunkOffset = mp4ChunkOffsetBuff[(INT16)(dwChunkNumber % MP4_CHUNK_OFFSET_BUFF_SIZE)];
}
if (((dwCurrentSampleNumber - dwFirstSampleNumberOfChunk) == dwSampleNumberPerChunk))
{
#ifndef MP4_NO_DUMMY_CHUNK
#if 0
mp4ChunkSizeBuff[MP4_CHUNK_SIZE_BUFF_SIZE - 1 - (INT16)(dwChunkNumber % MP4_CHUNK_SIZE_BUFF_SIZE)][0] = dwChunkOffset;
mp4ChunkSizeBuff[MP4_CHUNK_SIZE_BUFF_SIZE - 1 - (INT16)(dwChunkNumber % MP4_CHUNK_SIZE_BUFF_SIZE)][1] = dwChunkSize-dwCurrentSampleSize;
#else
mp4ChunkSizeBuff[MP4_CHUNK_SIZE_BUFF_SIZE - 1 - (INT16)(dwChunkNumber % MP4_CHUNK_SIZE_BUFF_SIZE)] = dwChunkSize-dwCurrentSampleSize;
#endif
if ((dwChunkNumber % MP4_CHUNK_SIZE_BUFF_SIZE) == (MP4_CHUNK_SIZE_BUFF_SIZE-1) ||
(dwChunkNumber == (mp4STCOEntryCount -1) ))
{
#if 0
wai_sem(SEM_DRAM_ID);
I49_WriteDRAMData(*dwChunkSizeAddr,(UINT16*)&mp4ChunkSizeBuff, ((MP4_CHUNK_SIZE_BUFF_SIZE*sizeof(DWORD))));
sig_sem(SEM_DRAM_ID);
*dwChunkSizeAddr += ((MP4_CHUNK_SIZE_BUFF_SIZE*sizeof(DWORD)));
#else
wai_sem(SEM_DRAM_ID);
I49_WriteDRAMData(*dwChunkSizeAddr,(UINT16*)&mp4ChunkSizeBuff, ((MP4_CHUNK_SIZE_BUFF_SIZE*sizeof(DWORD)) /2));
sig_sem(SEM_DRAM_ID);
*dwChunkSizeAddr += ((MP4_CHUNK_SIZE_BUFF_SIZE*sizeof(DWORD))/2);
#endif
}
#endif
dwFirstSampleNumberOfChunk = dwCurrentSampleNumber;
dwChunkSize = dwCurrentSampleSize;
dwChunkNumber ++;
if (((dwChunkNumber % MP4_CHUNK_OFFSET_BUFF_SIZE) == 0))
{
#ifdef MP4_PACK_STCO
if (TRUE == bPackSTCO)
{
_mp4LoadSTCOTable(dwSTCOAddr,mp4ChunkOffsetBuff,&dwPreChunkOffset);
dwSTCOAddr += MP4_PACK_STCO_BUFF_SIZE_IN_WORD;
}
else
#endif
{
wai_sem(SEM_DRAM_ID);
I49_ReadDRAMData(dwSTCOAddr,(UINT16*)&mp4ChunkOffsetBuff, ((MP4_CHUNK_OFFSET_BUFF_SIZE*sizeof(DWORD))/2));
sig_sem(SEM_DRAM_ID);
dwSTCOAddr += ((MP4_CHUNK_OFFSET_BUFF_SIZE*sizeof(DWORD))/2);
}
}
dwChunkOffset = mp4ChunkOffsetBuff[(INT16)(dwChunkNumber % MP4_CHUNK_OFFSET_BUFF_SIZE)];
}
if ((_mpeg4VideoStreamID != NO_STREAM) && (codecType != CODEC_TYPE_SUBPICTURE) && (codecType != CODEC_TYPE_SUBTITLE))
{
// get sync sample, from "stss", TBD_Robin
if (codecType == CODEC_TYPE_VIDEO)
{
if (TRUE == bFirstTime)
{
wai_sem(SEM_DRAM_ID);
I49_ReadDRAMData(dwVideoSTSSStartAdd,(UINT16*)&mp4SyncSampleBuff, ((MP4_SYNC_SAMPLE_BUFF_SIZE*sizeof(DWORD))/2));
sig_sem(SEM_DRAM_ID);
dwVideoSTSSStartAdd += ((MP4_SYNC_SAMPLE_BUFF_SIZE*sizeof(DWORD))/2);
dwSyncSampleNumber = mp4SyncSampleBuff[(INT16)(dwSyncNumber % MP4_SYNC_SAMPLE_BUFF_SIZE)] - 1;//_toBe32((BYTE*)&mp4SyncSampleBuff[(INT16)(dwSyncNumber % MP4_SYNC_SAMPLE_BUFF_SIZE)]) -1;
}
if (dwCurrentSampleNumber == dwSyncSampleNumber)
{
mp4VideoSyncEntry[MP4_SYNC_ENTRY_BUFF_SIZE - 1 - (INT16)(dwSyncNumber%MP4_SYNC_ENTRY_BUFF_SIZE)].dwSyncSampleNumber = dwSyncSampleNumber;
mp4VideoSyncEntry[MP4_SYNC_ENTRY_BUFF_SIZE - 1 - (INT16)(dwSyncNumber%MP4_SYNC_ENTRY_BUFF_SIZE)].dwSyncChunkOffset = dwChunkOffset;
mp4VideoSyncEntry[MP4_SYNC_ENTRY_BUFF_SIZE - 1 - (INT16)(dwSyncNumber%MP4_SYNC_ENTRY_BUFF_SIZE)].dwOffsetofChunk = dwChunkSize - dwCurrentSampleSize;
mp4VideoSyncEntry[MP4_SYNC_ENTRY_BUFF_SIZE - 1 - (INT16)(dwSyncNumber%MP4_SYNC_ENTRY_BUFF_SIZE)].dwSyncSampleSize = dwCurrentSampleSize;
if (((dwSyncNumber % MP4_SYNC_ENTRY_BUFF_SIZE) == (MP4_SYNC_ENTRY_BUFF_SIZE-1)) ||
(dwSyncNumber >= (mp4STSSEntryCount-1)))
{
*dwSyncSampleAddr -= MP4_VIDEO_SYNC_ENTRY_BUFF_SIZE;
wai_sem(SEM_DRAM_ID);
I49_WriteDRAMData(*dwSyncSampleAddr,(UINT16*)&mp4VideoSyncEntry, MP4_VIDEO_SYNC_ENTRY_BUFF_SIZE);
sig_sem(SEM_DRAM_ID);
}
dwSyncNumber ++;
if ((dwSyncNumber % MP4_SYNC_SAMPLE_BUFF_SIZE) == 0)
{
wai_sem(SEM_DRAM_ID);
I49_ReadDRAMData(dwVideoSTSSStartAdd,(UINT16*)&mp4SyncSampleBuff, ((MP4_SYNC_SAMPLE_BUFF_SIZE*sizeof(DWORD))/2));
sig_sem(SEM_DRAM_ID);
dwVideoSTSSStartAdd += ((MP4_SYNC_SAMPLE_BUFF_SIZE*sizeof(DWORD))/2);
}
if (dwSyncNumber >= _uiMPEG4NextIndexEntry)
dwSyncSampleNumber = 0xFFFFFFFFUL;
else
dwSyncSampleNumber = mp4SyncSampleBuff[(INT16)(dwSyncNumber % MP4_SYNC_SAMPLE_BUFF_SIZE)] - 1;//_toBe32((BYTE*)&mp4SyncSampleBuff[(INT16)(dwSyncNumber % MP4_SYNC_SAMPLE_BUFF_SIZE)]) -1;
}
// if (dwSyncNumber > mp4STSSEntryCount)
// {
// dbg_printf(("_mp4VideoSampleTableProcessing(): Too many sync sample n"));
// return FALSE;
// }
}
else if (codecType == CODEC_TYPE_AUDIO)
{
if (TRUE == bFirstTime)
{
wai_sem(SEM_DRAM_ID);
I49_ReadDRAMData(dwVideoSTSSStartAdd,(UINT16*)&mp4SyncSampleBuff, ((MP4_SYNC_SAMPLE_BUFF_SIZE*sizeof(DWORD))/2));
sig_sem(SEM_DRAM_ID);
dwVideoSTSSStartAdd += ((MP4_SYNC_SAMPLE_BUFF_SIZE*sizeof(DWORD))/2);
dwSyncSampleNumber = mp4SyncSampleBuff[(INT16)(dwSyncNumber % MP4_SYNC_SAMPLE_BUFF_SIZE)] - 1;//_toBe32((BYTE*)&mp4SyncSampleBuff[(INT16)(dwSyncNumber % MP4_SYNC_SAMPLE_BUFF_SIZE)]) -1;
dwSyncTime = dwSyncSampleNumber * dwVideoSkip;
dwSyncTime += ((dwSyncSampleNumber * dwVideoSkipRemider100)/ 100UL);
dwSyncTime += ((dwSyncSampleNumber * dwVideoSkipRemider10000) / 10000UL);
}
dwAudioTime += dwAudioSkip;
if ((dwCurrentSampleNumber % 100UL) == 0UL)
dwAudioTime += dwAudioSkipRemider100;
if ((dwCurrentSampleNumber % 10000UL) == 0UL)
dwAudioTime += dwAudioSkipRemider10000;
if (dwAudioTime >= dwSyncTime)
{
mp4AudioSyncEntry[MP4_SYNC_ENTRY_BUFF_SIZE - 1 - (INT16)(dwSyncNumber%MP4_SYNC_ENTRY_BUFF_SIZE)].dwSyncChunkOffset = dwChunkOffset;
mp4AudioSyncEntry[MP4_SYNC_ENTRY_BUFF_SIZE - 1 - (INT16)(dwSyncNumber%MP4_SYNC_ENTRY_BUFF_SIZE)].dwOffsetofChunk = dwChunkSize - dwCurrentSampleSize;
if ((dwSyncNumber % MP4_SYNC_ENTRY_BUFF_SIZE) == (MP4_SYNC_ENTRY_BUFF_SIZE-1) ||
(dwSyncNumber >= (mp4STSSEntryCount-1)))
{
*dwSyncSampleAddr -= MP4_AUDIO_SYNC_ENTRY_BUFF_SIZE;
wai_sem(SEM_DRAM_ID);
I49_WriteDRAMData(*dwSyncSampleAddr,(UINT16*)&mp4AudioSyncEntry, MP4_AUDIO_SYNC_ENTRY_BUFF_SIZE);
sig_sem(SEM_DRAM_ID);
}
dwSyncNumber ++;
if ((dwSyncNumber % MP4_SYNC_SAMPLE_BUFF_SIZE) == 0)
{
wai_sem(SEM_DRAM_ID);
I49_ReadDRAMData(dwVideoSTSSStartAdd,(UINT16*)&mp4SyncSampleBuff, ((MP4_SYNC_SAMPLE_BUFF_SIZE*sizeof(DWORD))/2));
sig_sem(SEM_DRAM_ID);
dwVideoSTSSStartAdd += ((MP4_SYNC_SAMPLE_BUFF_SIZE*sizeof(DWORD))/2);
}
if (dwSyncNumber >= _uiMPEG4NextIndexEntry)
dwSyncTime = 0xFFFFFFFFUL;
else
{
dwSyncSampleNumber = mp4SyncSampleBuff[(INT16)(dwSyncNumber % MP4_SYNC_SAMPLE_BUFF_SIZE)] - 1;//_toBe32((BYTE*)&mp4SyncSampleBuff[(INT16)(dwSyncNumber % MP4_SYNC_SAMPLE_BUFF_SIZE)]) -1;
dwSyncTime = dwSyncSampleNumber * dwVideoSkip;
dwSyncTime += ((dwSyncSampleNumber * dwVideoSkipRemider100)/ 100UL);
dwSyncTime += ((dwSyncSampleNumber * dwVideoSkipRemider10000) / 10000UL);
}
}
}
}
else if ((_mpeg4VideoStreamID == NO_STREAM) && (codecType == CODEC_TYPE_AUDIO))
{
dwAudioTime += dwAudioSkip;
if ((dwCurrentSampleNumber % 100UL) == 0UL)
dwAudioTime += dwAudioSkipRemider100;
if ((dwCurrentSampleNumber % 10000UL) == 0UL)
dwAudioTime += dwAudioSkipRemider10000;
while ((dwAudioTime/10000UL) - wAudioOnlySyncTime >= 1)
{
wAudioOnlySyncTime ++;
mp4AudioSyncEntry[0].dwSyncChunkOffset = dwChunkOffset;
mp4AudioSyncEntry[0].dwOffsetofChunk = dwChunkSize - dwCurrentSampleSize;
*dwSyncSampleAddr -= MP4_AUDIO_SYNC_ENTRY_SIZE;
wai_sem(SEM_DRAM_ID);
I49_WriteDRAMData(*dwSyncSampleAddr,(UINT16*)&mp4AudioSyncEntry, MP4_AUDIO_SYNC_ENTRY_SIZE);
sig_sem(SEM_DRAM_ID);
dwSyncNumber ++;
}
}
else if (codecType == CODEC_TYPE_SUBTITLE || codecType == CODEC_TYPE_SUBPICTURE)
{
// get decoding time to sample box, "stts"
if ((TRUE == bFirstTime) || (dwCurrentSampleNumber == dwSampleCount))
{
wai_sem(SEM_DRAM_ID);
I49_ReadDRAMData(mp4STTSStartAddr,(UINT16*)&mp4TimeToSampleEntry, (sizeof(MP4TimeToSampleEntry)/2));
sig_sem(SEM_DRAM_ID);
mp4STTSStartAddr += (sizeof(MP4TimeToSampleEntry)/2);
dwSampleCount += mp4TimeToSampleEntry.dwSampleCount;//_toBe32((BYTE*)&mp4TimeToSampleEntry.dwSampleCount);
dwSampleTimeDelta = mp4TimeToSampleEntry.dwSampleDelta;//_toBe32((BYTE*)&mp4TimeToSampleEntry.dwSampleDelta);
}
dwCurrentSampleReminder += dwSampleTimeDelta;
dwCurrentSampleTimeDelta = dwCurrentSampleReminder / _mpeg4SubtitleTimeScale;
dwCurrentSampleTime += dwCurrentSampleTimeDelta;
dwCurrentSampleReminder -= (dwCurrentSampleTimeDelta * _mpeg4SubtitleTimeScale);
dwCurrentSampleTime10 = (10 * dwCurrentSampleReminder) / _mpeg4SubtitleTimeScale;
dwCurrentSampleTime1000 = dwCurrentSampleTime*1000 + dwCurrentSampleTime10*100;
mp4SubtitleSampleEntry[MP4_SUBTITLE_SAMPLE_ENTRY_BUFF_SIZE - 1 -(dwCurrentSampleNumber % MP4_SUBTITLE_SAMPLE_ENTRY_BUFF_SIZE)].dwChunkOffset = dwChunkOffset;
mp4SubtitleSampleEntry[MP4_SUBTITLE_SAMPLE_ENTRY_BUFF_SIZE - 1 -(dwCurrentSampleNumber % MP4_SUBTITLE_SAMPLE_ENTRY_BUFF_SIZE)].dwSampleSize = dwCurrentSampleSize;
if (codecType == CODEC_TYPE_SUBTITLE)
mp4SubtitleSampleEntry[MP4_SUBTITLE_SAMPLE_ENTRY_BUFF_SIZE - 1 - (dwCurrentSampleNumber % MP4_SUBTITLE_SAMPLE_ENTRY_BUFF_SIZE)].dwSampleEndTime = dwCurrentSampleTime1000;
else
mp4SubtitleSampleEntry[MP4_SUBTITLE_SAMPLE_ENTRY_BUFF_SIZE - 1 - (dwCurrentSampleNumber % MP4_SUBTITLE_SAMPLE_ENTRY_BUFF_SIZE)].dwSampleEndTime = dwPrevSampleTime1000;