DVD

开发平台：

Others

MP4.c：源码内容

dwPrevSampleTime1000 = dwCurrentSampleTime1000;
if ((dwCurrentSampleNumber % MP4_SUBTITLE_SAMPLE_ENTRY_BUFF_SIZE) == (MP4_SUBTITLE_SAMPLE_ENTRY_BUFF_SIZE -1))
{
*dwSyncSampleAddr -= MP4_SUBTITLE_SMAPLE_ENTRY_BUFF_SIZE;
wai_sem(SEM_DRAM_ID);
I49_WriteDRAMData(*dwSyncSampleAddr,(UINT16*)&mp4SubtitleSampleEntry, MP4_SUBTITLE_SMAPLE_ENTRY_BUFF_SIZE);
sig_sem(SEM_DRAM_ID);
}
}
bFirstTime = FALSE;
}
if (codecType == CODEC_TYPE_VIDEO)
if (dwSyncNumber < _uiMPEG4NextIndexEntry)
_uiMPEG4NextIndexEntry = (UINT16)(dwSyncNumber&0xFFFF);
if ((_mpeg4VideoStreamID == NO_STREAM) && (codecType == CODEC_TYPE_AUDIO))
{
_uiMPEG4NextIndexEntry = dwSyncNumber;
}
#ifdef D_ENABLE_AAC_SUPPORT
if ((codecType == CODEC_TYPE_AUDIO) && (_mpeg4AudioCodec == AAC))
{
if(_mpeg4AudioInfo_AAC.maxBlockSize > 0x1000)
tr_printf(("The max AAC block size is greater than 0x1000!n"));
else
tr_printf(("Max AAC block size is %dn", _mpeg4AudioInfo_AAC.maxBlockSize));
}
#endif
if (dwChunkNumber != mp4STCOEntryCount)
{
dbg_printf(("MP4 Chunk Number is not equal!n"));
dbg_printf(("Chunk Number Save: 0x%lx, Totla: 0x%lxn", dwChunkNumber, mp4STCOEntryCount));
sc_GetBytes(wSampleTableAddrEXAddr,0,SIZE_OF_MP4StreamSampleTableAddrEX,(BYTE*)&mp4StreamSampleTableAddrEX);
mp4STCOEntryCount = dwChunkNumber;
mp4STSCEntryCount = dwChunkNumber;
sc_SetBytes(wSampleTableAddrEXAddr,0,SIZE_OF_MP4StreamSampleTableAddrEX,(BYTE*)&mp4StreamSampleTableAddrEX);
}
*dwChunkSizeAddr = (((*dwChunkSizeAddr) + 0x1FFUL)>>9)<<9;
*dwSyncSampleAddr = (*dwSyncSampleAddr>>9)<<9; // descend
return TRUE;
}
#ifndef MP4_STORE_SAMPLETABLE_AFTER
///////////////////////////////////////////////////////////////////////////
// Function name : _mp4SampleTableProcssing
// Purpose : MP4 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 _mp4SampleTableProcessing(DWORD dwStartAddr)
{
WORD wSampleTableAddrEXAddr = SC_MPEG4_VIDEO_SAMPLE_TABLE_ADDREX_BUFF_ADDR;
MP4_CODEC_TYPE codecType = CODEC_TYPE_VIDEO;
// DWORD dwAudioScale = 0, dwAudioRate = 0;
DWORD dwSyncSampleAddr; // descend
DWORD dwChunkSizeAddr;
MP4StreamSampleTableAddrEX mp4StreamSampleTableAddrEX;
// DWORD dwMP4VideoSTSSEntryCount;
BYTE currAudioStreamNum;
DWORD dwmp4VideoSTSSStartAdd;
BYTE currSubStreamNum;
if (_bMPEG4IsIndexProcessed == TRUE)
return TRUE;
_dwMPEG4ProcessingEndAddr = MPEG4_PROCESSING_BUFF_ADDR;
if (_mpeg4VideoStreamID != NO_STREAM)
{
// video sample table address
sc_GetBytes(wSampleTableAddrEXAddr,
0,SIZE_OF_MP4StreamSampleTableAddrEX,(BYTE*)&mp4StreamSampleTableAddrEX);
if (mp4STSSEntryCount >= 0x10000UL)
{
_uiMPEG4NextIndexEntry = 0xFFFF;
dbg_printf(("WARNING: MP4 Sync Sample is more than 65535 n"));
}
else
_uiMPEG4NextIndexEntry = (UINT16)(mp4STSSEntryCount & 0xFFFF);
mp4ChunkSizeStartAddr = _dwMP4SampleTableAddr;
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));
}
else
{
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);
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));
#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);
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));
}
_dwMP4ChunkSizeStartAddr = dwSyncSampleAddr;
return TRUE;
}
#endif
#ifdef MP4_PACK_TRANSFER_CHUNK_SIZE
static void _mp4StorePackTransferChunkSize(DWORD dwChunkSizeAddr, DWORD* pChunkSizeBuff)
{
if (TRUE == bMP4NeedPack)
{
WORD wCount;
DWORD dwChunkSize;
DWORD dwStreamID;
DWORD pPackBuff[MP4_PACK_CHUNK_SIZE_TABLE_BUFF_SIZE];
WORD wPackBuffOffset = 0; // in byte
WORD wPackBuffBitOffset = 0;
memset((BYTE*)&pPackBuff[0],0,sizeof(pPackBuff));
for(wCount=0;wCount<MP4_CHUNK_SIZE_TABLE_BUFF_SIZE;wCount++)
{
dwChunkSize = (*pChunkSizeBuff) >> 8;
dwStreamID = (*pChunkSizeBuff) & 0xFFUL;
pPackBuff[wPackBuffOffset] += (dwStreamID<<wPackBuffBitOffset);
wPackBuffBitOffset += 4; // RB_TBD
if (wPackBuffBitOffset>16)
{
pPackBuff[wPackBuffOffset] += (dwChunkSize << wPackBuffBitOffset);
wPackBuffOffset++;
pPackBuff[wPackBuffOffset] += (dwChunkSize >> (32-wPackBuffBitOffset));
wPackBuffBitOffset = wPackBuffBitOffset - 16;
}
else
{
pPackBuff[wPackBuffOffset] += (dwChunkSize << wPackBuffBitOffset);
if (wPackBuffBitOffset == 16)
{
wPackBuffBitOffset = 0;
wPackBuffOffset ++;
}
else
wPackBuffBitOffset += 16;
}
pChunkSizeBuff++;
}
wai_sem(SEM_DRAM_ID);
I49_WriteDRAMData(dwChunkSizeAddr,(UINT16*)&pPackBuff, MP4_PACK_CHUNK_SIZE_ENTRY_BUFF_SIZE);
sig_sem(SEM_DRAM_ID);
}
else
{
wai_sem(SEM_DRAM_ID);
I49_WriteDRAMData(dwChunkSizeAddr,(UINT16*)pChunkSizeBuff, MP4_CHUNK_SIZE_ENTRY_BUFF_SIZE);
sig_sem(SEM_DRAM_ID);
}
}
static void _mp4LoadPackTransferChunkSize(DWORD dwChunkSizeAddr, DWORD* pChunkSizeBuff)
{
if (TRUE == bMP4NeedPack)
{
WORD wCount;
DWORD dwChunkSize;
DWORD dwStreamID;
DWORD pPackBuff[MP4_PACK_CHUNK_SIZE_TABLE_BUFF_SIZE];
WORD wPackBuffOffset = 0; // in byte
WORD wPackBuffBitOffset = 0;
wai_sem(SEM_DRAM_ID);
I49_ReadDRAMData(dwChunkSizeAddr,(UINT16*)&pPackBuff, MP4_PACK_CHUNK_SIZE_ENTRY_BUFF_SIZE);
sig_sem(SEM_DRAM_ID);
for(wCount=0;wCount<MP4_CHUNK_SIZE_TABLE_BUFF_SIZE;wCount++)
{
dwStreamID = (pPackBuff[wPackBuffOffset] >> wPackBuffBitOffset) & 0xFUL;
wPackBuffBitOffset += 4; // RB_TBD
if (wPackBuffBitOffset>16)
{
dwChunkSize = (pPackBuff[wPackBuffOffset] >> wPackBuffBitOffset);
wPackBuffOffset++;
dwChunkSize += (pPackBuff[wPackBuffOffset] << (32-wPackBuffBitOffset));
dwChunkSize = dwChunkSize & 0xFFFFUL;
wPackBuffBitOffset = wPackBuffBitOffset - 16;
}
else
{
dwChunkSize = (pPackBuff[wPackBuffOffset] >> wPackBuffBitOffset) & 0xFFFFUL;
if (wPackBuffBitOffset == 16)
{
wPackBuffBitOffset = 0;
wPackBuffOffset ++;
}
else
wPackBuffBitOffset += 16;
}
(*pChunkSizeBuff++) = (dwChunkSize << 8) + dwStreamID;
}
}
else
{
wai_sem(SEM_DRAM_ID);
I49_ReadDRAMData(dwChunkSizeAddr,(UINT16*)pChunkSizeBuff, MP4_CHUNK_SIZE_ENTRY_BUFF_SIZE);
sig_sem(SEM_DRAM_ID);
}
}
static DWORD _mp4CalculatePackTransferChunkSize(DWORD dwChunkSizeAddr, DWORD* pChunkSizeBuff)
{
DWORD dwCaculateChunkSize = 0;
WORD wCount;
DWORD dwChunkSize;
WORD wPackBuffOffset = 0; // in byte
WORD wPackBuffBitOffset = 0;
if (TRUE == bMP4NeedPack)
{
wai_sem(SEM_DRAM_ID);
I49_ReadDRAMData(dwChunkSizeAddr,(UINT16*)pChunkSizeBuff, MP4_PACK_CHUNK_SIZE_ENTRY_BUFF_SIZE2);
sig_sem(SEM_DRAM_ID);
for(wCount=0;wCount<MP4_CHUNK_SIZE_TABLE_BUFF_SIZE2;wCount++)
{
wPackBuffBitOffset += 4; // RB_TBD
if (wPackBuffBitOffset>16)
{
dwChunkSize = (pChunkSizeBuff[wPackBuffOffset] >> wPackBuffBitOffset);
wPackBuffOffset++;
dwChunkSize += (pChunkSizeBuff[wPackBuffOffset] << (32-wPackBuffBitOffset));
dwChunkSize = dwChunkSize & 0xFFFFUL;
wPackBuffBitOffset = wPackBuffBitOffset - 16;
}
else
{
dwChunkSize = (pChunkSizeBuff[wPackBuffOffset] >> wPackBuffBitOffset) & 0xFFFFUL;
if (wPackBuffBitOffset == 16)
{
wPackBuffBitOffset = 0;
wPackBuffOffset ++;
}
else
wPackBuffBitOffset += 16;
}
dwCaculateChunkSize += dwChunkSize;
}
}
else
{
wai_sem(SEM_DRAM_ID);
I49_ReadDRAMData(dwChunkSizeAddr,(UINT16*)pChunkSizeBuff, MP4_CHUNK_SIZE_ENTRY_BUFF_SIZE2);
sig_sem(SEM_DRAM_ID);
for(wCount=0;wCount<MP4_CHUNK_SIZE_TABLE_BUFF_SIZE2;wCount++)
{
dwCaculateChunkSize += (pChunkSizeBuff[wCount] >> 8);
}
}
return dwCaculateChunkSize;
}
#endif
///////////////////////////////////////////////////////////////////////////
// Function name : _mp4ChunkSizeProcessing
// Purpose : MP4 Chunk Size Processing to Chunk Size Table.
// Input Parameters : dwStartAddr - The start address to get the BOX.
// Return type : TRUE - if succeeded, FALSE otherwise.
///////////////////////////////////////////////////////////////////////////
static BOOL _mp4ChunkSizeProcessing(void)
{
MP4StreamChunkSizeBuff *pStreamChunkSizeBuff;
DWORD dwStreamChunkFlag = 0UL, dwCurrStreamChunkFlag = 0UL; //
MP4StreamSampleTableAddrEX mp4StreamSampleTableAddrEX;
int iStreamNumber;
WORD wSampleTableAddrEXAddr;
DWORD dwChunkOffset = 0xFFFFFFFFUL;
DWORD dwChunkSize;
DWORD dwPreChunkOffset = 0;
int iCurrStreamNumber;
int iPrevStreamNumber;
BOOL bFirstTime = TRUE;
DWORD dwChunkCount = 0;
DWORD dwChunkSizeAddr = _dwMP4ChunkSizeStartAddr;
DWORD dwChunkNumber = 0;
if (_bMPEG4IsIndexProcessed == TRUE)
return TRUE;
pStreamChunkSizeBuff = (BYTE*)malloc((1+_mpeg4AudioAvailableNum+_mpeg4SubtitleAvailableNum + uiMP4ReservedNum) * sizeof(MP4StreamChunkSizeBuff));
if (NULL == pStreamChunkSizeBuff)
{
tr_printf(("FATAL: couldn't allocate memory for chunk size buffer ...n"));
return FALSE;
}
for (iStreamNumber=0;iStreamNumber<=(_mpeg4AudioAvailableNum+_mpeg4SubtitleAvailableNum + uiMP4ReservedNum);iStreamNumber++)
{
if (iStreamNumber <= _mpeg4AudioAvailableNum)
wSampleTableAddrEXAddr = SC_MPEG4_VIDEO_SAMPLE_TABLE_ADDREX_BUFF_ADDR + (iStreamNumber * SIZE_OF_MP4StreamSampleTableAddrEX_IN_DWORD);
else if (iStreamNumber <= (_mpeg4AudioAvailableNum+_mpeg4SubtitleAvailableNum))
wSampleTableAddrEXAddr = SC_MPEG4_VIDEO_SAMPLE_TABLE_ADDREX_BUFF_ADDR + ((iStreamNumber - _mpeg4AudioAvailableNum + MAX_AUDS_PER_CLIP)* SIZE_OF_MP4StreamSampleTableAddrEX_IN_DWORD);
else
wSampleTableAddrEXAddr = SC_MPEG4_VIDEO_SAMPLE_TABLE_ADDREX_BUFF_ADDR + ((iStreamNumber - _mpeg4AudioAvailableNum - _mpeg4SubtitleAvailableNum + MAX_AUDS_PER_CLIP + MAX_SUB_PER_CLIP)* SIZE_OF_MP4StreamSampleTableAddrEX_IN_DWORD);
sc_GetBytes(wSampleTableAddrEXAddr,
0,SIZE_OF_MP4StreamSampleTableAddrEX,(BYTE*)&mp4StreamSampleTableAddrEX);
pStreamChunkSizeBuff[iStreamNumber].dwStreamChunkOffsetAddr = mp4STCOStartAddr;
#ifndef MP4_NO_DUMMY_CHUNK
pStreamChunkSizeBuff[iStreamNumber].dwStreamChunkSizeAddr = mp4ChunkSizeStartAddr;
#endif
pStreamChunkSizeBuff[iStreamNumber].dwStreamChunkTotal = mp4STCOEntryCount;
dwChunkNumber += mp4STCOEntryCount;
pStreamChunkSizeBuff[iStreamNumber].dwStreamChunkNumber = 0;
dwStreamChunkFlag = dwStreamChunkFlag | (1UL<<iStreamNumber);
#ifdef MP4_PACK_STCO
pStreamChunkSizeBuff[iStreamNumber].bPackSTCO = mp4PackSTCO;
if (TRUE == pStreamChunkSizeBuff[iStreamNumber].bPackSTCO)
{
wai_sem(SEM_DRAM_ID);
I49_ReadDRAMData(pStreamChunkSizeBuff[iStreamNumber].dwStreamChunkOffsetAddr,(UINT16*)&(pStreamChunkSizeBuff[iStreamNumber].dwPrevChunkOffset), (sizeof(DWORD)/2));
sig_sem(SEM_DRAM_ID);
pStreamChunkSizeBuff[iStreamNumber].dwStreamChunkOffsetAddr += (sizeof(DWORD)/2);
}
#endif
}
if(dwChunkNumber >= MP4_PACK_CHUNK_NUMBER_THRESHOLD)
{
bMP4NeedPack = TRUE;
tr_printf(("nWARNING: Total Chunk Number is large than %ld: %ldn", MP4_PACK_CHUNK_NUMBER_THRESHOLD, dwChunkNumber));
}
else
bMP4NeedPack = FALSE;
if (TRUE == bMP4NeedPack)
dwMP4MaxStoreChunkSize = 0xFFFFUL;
else
dwMP4MaxStoreChunkSize = 0xFFFF00UL;
if (_mpeg4VideoStreamID == NO_STREAM)
pStreamChunkSizeBuff[0].dwStreamChunkTotal = 0;
for (iStreamNumber=0;iStreamNumber<=(_mpeg4AudioAvailableNum+_mpeg4SubtitleAvailableNum + uiMP4ReservedNum);iStreamNumber++)
{
#ifdef MP4_PACK_STCO
if (TRUE == pStreamChunkSizeBuff[iStreamNumber].bPackSTCO)
{
_mp4LoadSTCOTable(pStreamChunkSizeBuff[iStreamNumber].dwStreamChunkOffsetAddr,&(pStreamChunkSizeBuff[iStreamNumber].OffsetBuff[0]),&(pStreamChunkSizeBuff[iStreamNumber].dwPrevChunkOffset));
pStreamChunkSizeBuff[iStreamNumber].dwStreamChunkOffsetAddr += MP4_PACK_STCO_BUFF_SIZE_IN_WORD;
}
else
#endif
{
wai_sem(SEM_DRAM_ID);
I49_ReadDRAMData(pStreamChunkSizeBuff[iStreamNumber].dwStreamChunkOffsetAddr ,(UINT16*)&(pStreamChunkSizeBuff[iStreamNumber].OffsetBuff[0]), (MP4_CHUNK_SIZE_BUFF_SIZE*sizeof(DWORD)/2));
#ifndef MP4_NO_DUMMY_CHUNK
I49_ReadDRAMData(pStreamChunkSizeBuff[iStreamNumber].dwStreamChunkSizeAddr ,(UINT16*)&(pStreamChunkSizeBuff[iStreamNumber].SizeBuff[0]), (MP4_CHUNK_SIZE_BUFF_SIZE*sizeof(DWORD)/2));
#endif
sig_sem(SEM_DRAM_ID);
#ifndef MP4_NO_DUMMY_CHUNK
pStreamChunkSizeBuff[iStreamNumber].dwStreamChunkSizeAddr += (MP4_CHUNK_SIZE_BUFF_SIZE*sizeof(DWORD)/2);
#endif
pStreamChunkSizeBuff[iStreamNumber].dwStreamChunkOffsetAddr += (MP4_CHUNK_SIZE_BUFF_SIZE*sizeof(DWORD)/2);
}
pStreamChunkSizeBuff[iStreamNumber].dwStreamChunkOffset = pStreamChunkSizeBuff[iStreamNumber].OffsetBuff[(INT16)(pStreamChunkSizeBuff[iStreamNumber].dwStreamChunkNumber % MP4_CHUNK_SIZE_BUFF_SIZE)];
}
while (TRUE)
{
// search the samllest chunk offset
for (iStreamNumber=0;iStreamNumber<=(_mpeg4AudioAvailableNum+_mpeg4SubtitleAvailableNum + uiMP4ReservedNum);iStreamNumber++)
{
if (pStreamChunkSizeBuff[iStreamNumber].dwStreamChunkNumber == pStreamChunkSizeBuff[iStreamNumber].dwStreamChunkTotal)
{
if (iStreamNumber == (_mpeg4AudioAvailableNum+_mpeg4SubtitleAvailableNum + uiMP4ReservedNum))
{
if (iStreamNumber > _mpeg4AudioAvailableNum+_mpeg4SubtitleAvailableNum )
uiMP4ReservedNum --;
}
dwCurrStreamChunkFlag = dwCurrStreamChunkFlag | (1UL<<iStreamNumber);
if (dwCurrStreamChunkFlag == dwStreamChunkFlag)
dwChunkOffset = _dwMP4LastChunkEndOffset;
continue;
}
if (pStreamChunkSizeBuff[iStreamNumber].dwStreamChunkOffset < dwChunkOffset)
{
dwChunkOffset = pStreamChunkSizeBuff[iStreamNumber].dwStreamChunkOffset;
#ifndef MP4_NO_DUMMY_CHUNK
dwChunkSize = pStreamChunkSizeBuff[iStreamNumber].SizeBuff[MP4_CHUNK_SIZE_BUFF_SIZE - 1 - (INT16)(pStreamChunkSizeBuff[iStreamNumber].dwStreamChunkNumber % MP4_CHUNK_SIZE_BUFF_SIZE)];
#endif
iCurrStreamNumber = iStreamNumber;
}
}
pStreamChunkSizeBuff[iCurrStreamNumber].dwStreamChunkNumber++;
if (pStreamChunkSizeBuff[iCurrStreamNumber].dwStreamChunkNumber % MP4_CHUNK_SIZE_BUFF_SIZE == 0)
{
#ifdef MP4_PACK_STCO
if (TRUE == pStreamChunkSizeBuff[iCurrStreamNumber].bPackSTCO)
{
_mp4LoadSTCOTable(pStreamChunkSizeBuff[iCurrStreamNumber].dwStreamChunkOffsetAddr,&(pStreamChunkSizeBuff[iCurrStreamNumber].OffsetBuff[0]),&(pStreamChunkSizeBuff[iCurrStreamNumber].dwPrevChunkOffset));
pStreamChunkSizeBuff[iCurrStreamNumber].dwStreamChunkOffsetAddr += MP4_PACK_STCO_BUFF_SIZE_IN_WORD;
}
else
#endif
{
wai_sem(SEM_DRAM_ID);
I49_ReadDRAMData(pStreamChunkSizeBuff[iCurrStreamNumber].dwStreamChunkOffsetAddr ,(UINT16*)&(pStreamChunkSizeBuff[iCurrStreamNumber].OffsetBuff[0]), (MP4_CHUNK_SIZE_BUFF_SIZE*sizeof(DWORD)/2));
#ifndef MP4_NO_DUMMY_CHUNK
I49_ReadDRAMData(pStreamChunkSizeBuff[iStreamNumber].dwStreamChunkSizeAddr ,(UINT16*)&(pStreamChunkSizeBuff[iStreamNumber].SizeBuff[0]), (MP4_CHUNK_SIZE_BUFF_SIZE*sizeof(DWORD)/2));
#endif
sig_sem(SEM_DRAM_ID);
#ifndef MP4_NO_DUMMY_CHUNK
pStreamChunkSizeBuff[iStreamNumber].dwStreamChunkSizeAddr += (MP4_CHUNK_SIZE_BUFF_SIZE*sizeof(DWORD)/2);
#endif
pStreamChunkSizeBuff[iCurrStreamNumber].dwStreamChunkOffsetAddr += (MP4_CHUNK_SIZE_BUFF_SIZE*sizeof(DWORD)/2);
}
}
pStreamChunkSizeBuff[iCurrStreamNumber].dwStreamChunkOffset = pStreamChunkSizeBuff[iCurrStreamNumber].OffsetBuff[(INT16)(pStreamChunkSizeBuff[iCurrStreamNumber].dwStreamChunkNumber % MP4_CHUNK_SIZE_BUFF_SIZE)];
#ifndef MP4_NO_DUMMY_CHUNK
if (dwCurrStreamChunkFlag == dwStreamChunkFlag)
break;
#endif
if (TRUE == bFirstTime)
{
#ifdef MP4_NO_DUMMY_CHUNK
_dwMP4FirstChunkOffset = dwChunkOffset;
dwPreChunkOffset = dwChunkOffset;
iPrevStreamNumber = iCurrStreamNumber;
// _dwMP4LastChunkEndOffset = dwChunkOffset;
if (iCurrStreamNumber <= (_mpeg4AudioAvailableNum+_mpeg4SubtitleAvailableNum))
bFirstTime = FALSE;
#else
_dwMP4FirstChunkOffset = dwChunkOffset;
_dwMP4LastChunkEndOffset = dwChunkOffset + dwChunkSize;
#ifdef PRINTF_MP4_CHUNK_SIZE
if (dwChunkCount < MAX_PRINTF_CHUNK_NUM)
{
dbg_printf(("ChunkCount: 0x%8lx, ChunkOffset: 0x%8lx, ChunkSize: %8ld, ChunkType: %2xn",
dwChunkCount,dwChunkOffset,dwChunkSize, iCurrStreamNumber));
}
#endif
_dwMP4ChunkSizeBuff[MP4_CHUNK_SIZE_TABLE_BUFF_SIZE - 1 - (INT16)(dwChunkCount%MP4_CHUNK_SIZE_TABLE_BUFF_SIZE)] = ((dwChunkSize<<8) + iCurrStreamNumber);
dwChunkCount++;
bFirstTime = FALSE;
#endif
}
else
{
#ifdef MP4_NO_DUMMY_CHUNK
while (dwChunkOffset > dwPreChunkOffset)
{
DWORD dwChunkSizeTemp;
dwChunkSizeTemp = min((dwChunkOffset - dwPreChunkOffset), dwMP4MaxStoreChunkSize);
#ifdef PRINTF_MP4_CHUNK_SIZE
if (dwChunkCount < MAX_PRINTF_CHUNK_NUM)
{
dbg_printf(("ChunkCount: %8lx, ChunkOffset: %8lx, ChunkSize: %8lx, ChunkType: %2xn",
dwChunkCount,dwPreChunkOffset, dwChunkSizeTemp, iPrevStreamNumber));
}
#endif
_dwMP4ChunkSizeBuff[MP4_CHUNK_SIZE_TABLE_BUFF_SIZE - 1 - (INT16)(dwChunkCount%MP4_CHUNK_SIZE_TABLE_BUFF_SIZE)] = ((dwChunkSizeTemp<<8) + iPrevStreamNumber);
if ((dwChunkCount % MP4_CHUNK_SIZE_TABLE_BUFF_SIZE) == (MP4_CHUNK_SIZE_TABLE_BUFF_SIZE-1))
{
#ifdef MP4_PACK_TRANSFER_CHUNK_SIZE
if (TRUE == bMP4NeedPack)
dwChunkSizeAddr -= MP4_PACK_CHUNK_SIZE_ENTRY_BUFF_SIZE;
else
dwChunkSizeAddr -= MP4_CHUNK_SIZE_ENTRY_BUFF_SIZE;
_mp4StorePackTransferChunkSize(dwChunkSizeAddr, (DWORD*)&_dwMP4ChunkSizeBuff);
#else
dwChunkSizeAddr -= MP4_CHUNK_SIZE_ENTRY_BUFF_SIZE;
wai_sem(SEM_DRAM_ID);
I49_WriteDRAMData(dwChunkSizeAddr,(UINT16*)&_dwMP4ChunkSizeBuff, MP4_CHUNK_SIZE_ENTRY_BUFF_SIZE);
sig_sem(SEM_DRAM_ID);
#endif
}
dwChunkCount++;
dwPreChunkOffset += dwChunkSizeTemp;
}
iPrevStreamNumber = iCurrStreamNumber;
#else
while (dwChunkOffset > _dwMP4LastChunkEndOffset)
{
DWORD dwChunkSizeTemp;
dwChunkSizeTemp = min((dwChunkOffset - _dwMP4LastChunkEndOffset), dwMP4MaxStoreChunkSize);
#ifdef PRINTF_MP4_CHUNK_SIZE
if (dwChunkCount < MAX_PRINTF_CHUNK_NUM)
{
dbg_printf(("ChunkCount: %8lx, ChunkOffset: %8lx, ChunkSize: %8lx, ChunkType: %2xn",
dwChunkCount,_dwMP4LastChunkEndOffset, dwChunkSizeTemp, MP4_NOT_USED_STREAM_ID));
}
#endif
_dwMP4ChunkSizeBuff[MP4_CHUNK_SIZE_TABLE_BUFF_SIZE - 1 - (INT16)(dwChunkCount%MP4_CHUNK_SIZE_TABLE_BUFF_SIZE)] = ((dwChunkSizeTemp <<8) + MP4_NOT_USED_STREAM_ID);
if ((dwChunkCount % MP4_CHUNK_SIZE_TABLE_BUFF_SIZE) == (MP4_CHUNK_SIZE_TABLE_BUFF_SIZE-1))
{
#ifdef MP4_PACK_TRANSFER_CHUNK_SIZE
if (TRUE == bMP4NeedPack)
dwChunkSizeAddr -= MP4_PACK_CHUNK_SIZE_ENTRY_BUFF_SIZE;
else
dwChunkSizeAddr -= MP4_CHUNK_SIZE_ENTRY_BUFF_SIZE;
_mp4StorePackTransferChunkSize(dwChunkSizeAddr, (DWORD*)&_dwMP4ChunkSizeBuff);
#else
dwChunkSizeAddr -= MP4_CHUNK_SIZE_ENTRY_BUFF_SIZE;
wai_sem(SEM_DRAM_ID);
I49_WriteDRAMData(dwChunkSizeAddr,(UINT16*)&_dwMP4ChunkSizeBuff, MP4_CHUNK_SIZE_ENTRY_BUFF_SIZE);
sig_sem(SEM_DRAM_ID);
#endif
}
dwChunkCount++;
_dwMP4LastChunkEndOffset += dwChunkSizeTemp;
}
do
{
DWORD dwChunkSizeTemp;
dwChunkSizeTemp = min(dwChunkSize, dwMP4MaxStoreChunkSize);
#ifdef PRINTF_MP4_CHUNK_SIZE
if (dwChunkCount < MAX_PRINTF_CHUNK_NUM)
{
dbg_printf(("ChunkCount: %8lx, ChunkOffset: %8lx, ChunkSize: %8lx, ChunkType: %2xn",
dwChunkCount,_dwMP4LastChunkEndOffset, dwChunkSizeTemp, iCurrStreamNumber));
}
#endif
_dwMP4ChunkSizeBuff[MP4_CHUNK_SIZE_TABLE_BUFF_SIZE - 1 - (INT16)(dwChunkCount%MP4_CHUNK_SIZE_TABLE_BUFF_SIZE)] = ((dwChunkSizeTemp<<8) + iCurrStreamNumber);
if ((dwChunkCount % MP4_CHUNK_SIZE_TABLE_BUFF_SIZE) == (MP4_CHUNK_SIZE_TABLE_BUFF_SIZE-1))
{
#ifdef MP4_PACK_TRANSFER_CHUNK_SIZE
if (TRUE == bMP4NeedPack)
dwChunkSizeAddr -= MP4_PACK_CHUNK_SIZE_ENTRY_BUFF_SIZE;
else
dwChunkSizeAddr -= MP4_CHUNK_SIZE_ENTRY_BUFF_SIZE;
_mp4StorePackTransferChunkSize(dwChunkSizeAddr, (DWORD*)&_dwMP4ChunkSizeBuff);
#else
dwChunkSizeAddr -= MP4_CHUNK_SIZE_ENTRY_BUFF_SIZE;
wai_sem(SEM_DRAM_ID);
I49_WriteDRAMData(dwChunkSizeAddr,(UINT16*)&_dwMP4ChunkSizeBuff, MP4_CHUNK_SIZE_ENTRY_BUFF_SIZE);
sig_sem(SEM_DRAM_ID);
#endif
}
dwChunkCount++;
_dwMP4LastChunkEndOffset += dwChunkSizeTemp;
dwChunkSize -= dwChunkSizeTemp;
}while(dwChunkSize > 0UL);
#endif
}
#ifdef MP4_NO_DUMMY_CHUNK
if (dwCurrStreamChunkFlag == dwStreamChunkFlag)
break;
#endif
// _dwMP4LastChunkEndOffset = dwChunkOffset + dwChunkSize;
dwChunkOffset = 0xFFFFFFFFUL;
}
if ((dwChunkCount % MP4_CHUNK_SIZE_TABLE_BUFF_SIZE) != 0)
{
#ifdef MP4_PACK_TRANSFER_CHUNK_SIZE
if (TRUE == bMP4NeedPack)
dwChunkSizeAddr -= MP4_PACK_CHUNK_SIZE_ENTRY_BUFF_SIZE;
else
dwChunkSizeAddr -= MP4_CHUNK_SIZE_ENTRY_BUFF_SIZE;
_mp4StorePackTransferChunkSize(dwChunkSizeAddr, (DWORD*)&_dwMP4ChunkSizeBuff);
#else
dwChunkSizeAddr -= MP4_CHUNK_SIZE_ENTRY_BUFF_SIZE;
wai_sem(SEM_DRAM_ID);
I49_WriteDRAMData(dwChunkSizeAddr,(UINT16*)&_dwMP4ChunkSizeBuff, MP4_CHUNK_SIZE_ENTRY_BUFF_SIZE);
sig_sem(SEM_DRAM_ID);
#endif
}
_dwMP4ChunkSizeEntryTotal = dwChunkCount;
_dwMPEG4ProcessingEndAddr = dwChunkSizeAddr;
_dwMPEG4ProcessingEndAddr = (_dwMPEG4ProcessingEndAddr>>9)<<9;
tr_printf(("n_dwMP4ChunkSizeStartAddr: %ld KB, Size: %ld KBn", _dwMP4ChunkSizeStartAddr>>9, (_dwMP4ChunkSizeStartAddr - _dwMPEG4ProcessingEndAddr)>>9));
// _dwMP4ChunkSizeEndAddr = dwChunkSizeAddr;
free(pStreamChunkSizeBuff);
return TRUE;
}
static BOOL _mp4GetAdjacentIFrames(WORD wTime, DWORD *dwVideoSyncSampleNum, DWORD *dwSyncSampleOffset)
{
MP4VideoSyncEntry mp4VideoSyncEntry;
MP4AudioSyncEntry mp4AudioSyncEntry;
DWORD dwRequestedFrameNumber;
// DWORD dwIndex,dwSyncEntryAddr;
DWORD dwUpIndex,dwUpSyncEntryAddr;
DWORD dwDownIndex,dwDownSyncEntryAddr;
DWORD dwUpDiff, dwDownDiff, dwDiff;
DWORD dwAudioSyncSampleOffset;
WORD wSampleTableAddrEXAddr;
MP4StreamSampleTableAddrEX mp4StreamSampleTableAddrEX;
if (_mpeg4VideoStreamID == NO_STREAM)
{
_ulMPEG4RequestedFrameIndex = wTime;
// get the correspond audio sync
wSampleTableAddrEXAddr = SC_MPEG4_AUDIO_SAMPLE_TABLE_ADDREX_BUFF_ADDR + (_mpeg4AudioCurrentDispIdx * SIZE_OF_MP4StreamSampleTableAddrEX_IN_DWORD);
sc_GetBytes(wSampleTableAddrEXAddr,
0,SIZE_OF_MP4StreamSampleTableAddrEX,(BYTE*)&mp4StreamSampleTableAddrEX);
wSampleTableAddrEXAddr = SC_MPEG4_AUDIO_SAMPLE_TABLE_ADDREX_BUFF_ADDR + (_mpeg4AudioCurrentDispIdx * SIZE_OF_MP4StreamSampleTableAddrEX_IN_DWORD);
sc_GetBytes(wSampleTableAddrEXAddr,
0,SIZE_OF_MP4StreamSampleTableAddrEX,(BYTE*)&mp4StreamSampleTableAddrEX);
dwUpSyncEntryAddr = MP4_CALC_ENTRY_ADDRESS(mp4SyncEntryStartAddr, MP4_AUDIO_SYNC_ENTRY_SIZE, _ulMPEG4RequestedFrameIndex);
wai_sem(SEM_DRAM_ID);
I49_ReadDRAMData(dwUpSyncEntryAddr,(UINT16*)&mp4AudioSyncEntry, MP4_AUDIO_SYNC_ENTRY_SIZE);
sig_sem(SEM_DRAM_ID);
dwAudioSyncSampleOffset = mp4AudioSyncEntry.dwSyncChunkOffset/* + mp4AudioSyncEntry.dwOffsetofChunk*/;
*dwVideoSyncSampleNum = wTime * 30UL;
*dwSyncSampleOffset = dwAudioSyncSampleOffset;
return TRUE;
}
dwRequestedFrameNumber = caclFrameOfTime(wTime, _mpeg4VideoRate, _mpeg4VideoScale);
dwUpIndex = (dwRequestedFrameNumber * 1000UL) /_mpeg4VideoLength;
dwUpIndex = (dwUpIndex * _uiMPEG4NextIndexEntry) / 1000UL;
dwUpIndex = min(dwUpIndex, (_uiMPEG4NextIndexEntry-1));
dwUpSyncEntryAddr = MP4_CALC_ENTRY_ADDRESS(MPEG4_PROCESSING_BUFF_ADDR, MP4_VIDEO_SYNC_ENTRY_SIZE, dwUpIndex);
dwDownIndex = dwUpIndex;
dwDownSyncEntryAddr = dwUpSyncEntryAddr;
dwUpDiff = 0xFFFFFFFFUL;
dwDownDiff = 0xFFFFFFFFUL;
while (TRUE)
{
wai_sem(SEM_DRAM_ID);
I49_ReadDRAMData(dwUpSyncEntryAddr,(UINT16*)&mp4VideoSyncEntry, MP4_VIDEO_SYNC_ENTRY_SIZE);
sig_sem(SEM_DRAM_ID);
dwDiff = ABS_DIFF(mp4VideoSyncEntry.dwSyncSampleNumber,dwRequestedFrameNumber);
if (dwDiff > dwUpDiff)
break;
dwUpDiff = dwDiff;
dwUpIndex++;
if (dwUpIndex >= _uiMPEG4NextIndexEntry)
break;
dwUpSyncEntryAddr -= MP4_VIDEO_SYNC_ENTRY_SIZE;
}
while (TRUE)
{
wai_sem(SEM_DRAM_ID);
I49_ReadDRAMData(dwDownSyncEntryAddr,(UINT16*)&mp4VideoSyncEntry, MP4_VIDEO_SYNC_ENTRY_SIZE);
sig_sem(SEM_DRAM_ID);
dwDiff = ABS_DIFF(mp4VideoSyncEntry.dwSyncSampleNumber,dwRequestedFrameNumber);
if (dwDiff > dwDownDiff)
break;
dwDownDiff = dwDiff;
dwDownIndex --;
if ((INT32)dwDownIndex < 0)
break;
dwDownSyncEntryAddr += MP4_VIDEO_SYNC_ENTRY_SIZE;
}
if (dwDownDiff <= dwUpDiff)
_ulMPEG4RequestedFrameIndex = dwDownIndex+1;
else
_ulMPEG4RequestedFrameIndex = dwUpIndex-1;
if (PM_GetRepeatAB())
_ulMPEG4RequestedFrameIndex = dwUpIndex-1;
dwUpSyncEntryAddr = MP4_CALC_ENTRY_ADDRESS(MPEG4_PROCESSING_BUFF_ADDR, MP4_VIDEO_SYNC_ENTRY_SIZE, _ulMPEG4RequestedFrameIndex);
wai_sem(SEM_DRAM_ID);
I49_ReadDRAMData(dwUpSyncEntryAddr,(UINT16*)&mp4VideoSyncEntry, MP4_VIDEO_SYNC_ENTRY_SIZE);
sig_sem(SEM_DRAM_ID);
*dwVideoSyncSampleNum = mp4VideoSyncEntry.dwSyncSampleNumber;
*dwSyncSampleOffset = mp4VideoSyncEntry.dwSyncChunkOffset/* + mp4VideoSyncEntry.dwOffsetofChunk*/;
// get the correspond audio sync
wSampleTableAddrEXAddr = SC_MPEG4_AUDIO_SAMPLE_TABLE_ADDREX_BUFF_ADDR + (_mpeg4AudioCurrentDispIdx * SIZE_OF_MP4StreamSampleTableAddrEX_IN_DWORD);
sc_GetBytes(wSampleTableAddrEXAddr,
0,SIZE_OF_MP4StreamSampleTableAddrEX,(BYTE*)&mp4StreamSampleTableAddrEX);
dwUpSyncEntryAddr = MP4_CALC_ENTRY_ADDRESS(mp4SyncEntryStartAddr, MP4_AUDIO_SYNC_ENTRY_SIZE, _ulMPEG4RequestedFrameIndex);
wai_sem(SEM_DRAM_ID);
I49_ReadDRAMData(dwUpSyncEntryAddr,(UINT16*)&mp4AudioSyncEntry, MP4_AUDIO_SYNC_ENTRY_SIZE);
sig_sem(SEM_DRAM_ID);
dwAudioSyncSampleOffset = mp4AudioSyncEntry.dwSyncChunkOffset/* + mp4AudioSyncEntry.dwOffsetofChunk*/;
if (*dwSyncSampleOffset > dwAudioSyncSampleOffset)
*dwSyncSampleOffset = dwAudioSyncSampleOffset;
return TRUE;
}
static BOOL _mp4GetNextIFrames(UINT32 ulRequestedSampleNumber, UINT16* uiNextIIdx, MP4VideoSyncEntry* mp4VideoSyncEntry)
{
for((*uiNextIIdx)=0; (*uiNextIIdx) < _uiMPEG4NextIndexEntry; (*uiNextIIdx)++)
{
wai_sem(SEM_DRAM_ID);
I49_ReadDRAMData(MP4_CALC_ENTRY_ADDRESS(MPEG4_PROCESSING_BUFF_ADDR, (sizeof(MP4VideoSyncEntry)/2),*uiNextIIdx),
(UINT16*)mp4VideoSyncEntry, sizeof(MP4VideoSyncEntry)/2);
sig_sem(SEM_DRAM_ID);
if((mp4VideoSyncEntry->dwSyncSampleNumber) > ulRequestedSampleNumber)
{
break;
}
}
return TRUE;
}
static void _mp4SetFirstSkipBytes(BOOL bScan)
{
MP4VideoSyncEntry mp4VideoSyncEntry;
MP4AudioSyncEntry mp4AudioSyncEntry;
DWORD dwMP4VideosyncEntryAddr;
DWORD dwAudioSyncEntryAddr;
MP4StreamSampleTableAddrEX mp4StreamSampleTableAddrEX;
if ((FALSE == bScan) && (_mpeg4VideoStreamID != NO_STREAM))
{
dwMP4VideosyncEntryAddr = MP4_CALC_ENTRY_ADDRESS(MPEG4_PROCESSING_BUFF_ADDR, MP4_VIDEO_SYNC_ENTRY_SIZE, _ulMPEG4RequestedFrameIndex);
wai_sem(SEM_DRAM_ID);
I49_ReadDRAMData(dwMP4VideosyncEntryAddr,(UINT16*)&mp4VideoSyncEntry, MP4_VIDEO_SYNC_ENTRY_SIZE);
sig_sem(SEM_DRAM_ID);
sc_GetBytes(SC_MPEG4_AUDIO_SAMPLE_TABLE_ADDREX_BUFF_ADDR + (_mpeg4AudioCurrentDispIdx * SIZE_OF_MP4StreamSampleTableAddrEX_IN_DWORD),
0,SIZE_OF_MP4StreamSampleTableAddrEX,(BYTE*)&mp4StreamSampleTableAddrEX);
dwAudioSyncEntryAddr = MP4_CALC_ENTRY_ADDRESS(mp4SyncEntryStartAddr, MP4_AUDIO_SYNC_ENTRY_SIZE, _ulMPEG4RequestedFrameIndex);
wai_sem(SEM_DRAM_ID);
I49_ReadDRAMData(dwAudioSyncEntryAddr,(UINT16*)&mp4AudioSyncEntry, MP4_AUDIO_SYNC_ENTRY_SIZE);
sig_sem(SEM_DRAM_ID);
DEC_MP4_SetFirstSkipBytes(mp4VideoSyncEntry.dwOffsetofChunk, mp4AudioSyncEntry.dwOffsetofChunk, 0);
tr_printf(("First Skip Bytes of Video: %8lx, Audio: %8lxn", mp4VideoSyncEntry.dwOffsetofChunk, mp4AudioSyncEntry.dwOffsetofChunk));
}
else
{
DEC_MP4_SetFirstSkipBytes(0, 0, 0);
}
return;
}
#ifdef MP4_TANSFER_CHUNKSIZE_BY_FIFO
static void _mp4TransferChunkSizeByFifo(void)
{
BYTE chunkID;
BYTE preChunkID;
BOOL bFirstGetChunk;
WORD wTransferLength;
// DWORD mp4TransferChunkSizeBuff[MP4_TRANSFER_CHUNKSIZE_FIFO_LENGTH];
DWORD* mp4TransferChunkSizeBuff;
// BOOL bLastChunkIsNotUsed;
DWORD dwChunkSizeAddr;
DWORD dwChunkSize;
DWORD dwChunkSizeAndId;
mp4TransferChunkSizeBuff = (DWORD*)(&_MP4SharedBuff[0]);
if (FALSE == DEC_MP4_ChunkSizeFifoEmpty())
return;
preChunkID = MP4_NOT_USED_STREAM_ID;
chunkID = MP4_NOT_USED_STREAM_ID;
dwChunkSize = 0;
wTransferLength = 0;
// bLastChunkIsNotUsed = FALSE;
bFirstGetChunk = TRUE;
#ifdef PRINTF_MP4_TRANSFER_CHUNK_SIZE
{
dbg_printf(("ChunkSize Index : %lxn", _dwMP4ChunkSizeEntryIndex));
}
#endif
while (TRUE)
{
if (_dwMP4ChunkSizeEntryIndex > _dwMP4ChunkSizeEntryTotal)
break;
if (_dwMP4ChunkSizeEntryIndex == _dwMP4ChunkSizeEntryTotal)
{
mp4TransferChunkSizeBuff[wTransferLength++] = (((DWORD)preChunkID)<<24) + dwChunkSize;
_dwMP4ChunkSizeEntryIndex ++;
break;
}
dwChunkSizeAndId = _dwMP4ChunkSizeBuff[MP4_CHUNK_SIZE_TABLE_BUFF_SIZE - (INT16)(_dwMP4ChunkSizeEntryIndex%MP4_CHUNK_SIZE_TABLE_BUFF_SIZE) - 1];
preChunkID = chunkID;
chunkID = (BYTE)(dwChunkSizeAndId & 0xFF);
dwChunkSize += (dwChunkSizeAndId >> 8);
_dwMP4ChunkSizeEntryIndex++;
_dwMP4ChunkOffset += (dwChunkSizeAndId >> 8);
if (((chunkID == _mpeg4VideoStreamID) && (_dwMP4ChunkOffset <= _dwMP4VideoSyncOffset)) ||
((chunkID == _mpeg4AudioStreamID) && (_dwMP4ChunkOffset <= _dwMP4AudioSyncOffset)) /*||
((chunkID == _mpeg4SubtitleStreamID) && (_dwMP4ChunkOffset <= _dwMP4VideoSyncOffset))*/)
{
chunkID = MP4_NOT_USED_STREAM_ID;
}
if ((chunkID != _mpeg4VideoStreamID) && (chunkID != _mpeg4AudioStreamID) && (chunkID != _mpeg4SubtitleStreamID))
chunkID = MP4_NOT_USED_STREAM_ID;
if (FALSE == bFirstGetChunk)
{
if ((preChunkID != chunkID) || (dwChunkSize >= MP4_MAX_CHUNK_SIZE))
{
dwChunkSize -= (dwChunkSizeAndId >> 8);
mp4TransferChunkSizeBuff[wTransferLength++] = (((DWORD)preChunkID)<<24) + dwChunkSize;
//preChunkID = chunkID;
//dwChunkSize = (dwChunkSizeAndId >> 8);
_dwMP4ChunkSizeEntryIndex--;
_dwMP4ChunkOffset -= (dwChunkSizeAndId >> 8);
dwChunkSize = 0;
bFirstGetChunk = TRUE;
}
}
else
{
bFirstGetChunk = FALSE;
}
// mp4TransferChunkSizeBuff[wTransferLength++] = (((DWORD)chunkID)<<24) + dwChunkSize;
// dwChunkSize = 0;
if (_dwMP4ChunkSizeEntryIndex % MP4_CHUNK_SIZE_TABLE_BUFF_SIZE == 0)
{
#ifdef MP4_PACK_TRANSFER_CHUNK_SIZE
if (TRUE == bMP4NeedPack)
dwChunkSizeAddr = MP4_CALC_ENTRY_ADDRESS(_dwMP4ChunkSizeStartAddr, MP4_PACK_CHUNK_SIZE_ENTRY_BUFF_SIZE,
(_dwMP4ChunkSizeEntryIndex/MP4_CHUNK_SIZE_TABLE_BUFF_SIZE));
else
dwChunkSizeAddr = MP4_CALC_ENTRY_ADDRESS(_dwMP4ChunkSizeStartAddr, MP4_CHUNK_SIZE_ENTRY_BUFF_SIZE,
(_dwMP4ChunkSizeEntryIndex/MP4_CHUNK_SIZE_TABLE_BUFF_SIZE));
_mp4LoadPackTransferChunkSize(dwChunkSizeAddr, (DWORD*)&_dwMP4ChunkSizeBuff);
#else
dwChunkSizeAddr = MP4_CALC_ENTRY_ADDRESS(_dwMP4ChunkSizeStartAddr, MP4_CHUNK_SIZE_ENTRY_BUFF_SIZE,
(_dwMP4ChunkSizeEntryIndex/MP4_CHUNK_SIZE_TABLE_BUFF_SIZE));
wai_sem(SEM_DRAM_ID);
I49_ReadDRAMData(dwChunkSizeAddr,(UINT16*)&_dwMP4ChunkSizeBuff, MP4_CHUNK_SIZE_ENTRY_BUFF_SIZE);
sig_sem(SEM_DRAM_ID);
#endif
}
bFirstGetChunk = FALSE;
if (wTransferLength >= MP4_TRANSFER_CHUNKSIZE_FIFO_LENGTH)
break;
}
while (wTransferLength < MP4_TRANSFER_CHUNKSIZE_FIFO_LENGTH)
mp4TransferChunkSizeBuff[wTransferLength++] = 0xFFFFFFFFUL;
#ifdef PRINTF_MP4_TRANSFER_CHUNK_SIZE
{
int i;
for (i=0;i<MP4_TRANSFER_CHUNKSIZE_FIFO_LENGTH; i++)
{
dbg_printf(("Tansfer Chunk Offset: %8lx, Size: %8lx, Type: %2xn", dwTransferChunkOffset, mp4TransferChunkSizeBuff[i]&0xFFFFFFUL, mp4TransferChunkSizeBuff[i]>>24));
dwTransferChunkOffset += (mp4TransferChunkSizeBuff[i]&0xFFFFFFUL);
}
}
#endif
DEC_MP4_ChunkSizeFifoWrite(mp4TransferChunkSizeBuff);
return;
}
#endif
static void _mp4GetChunkSizeEntryIndex(BOOL bVideoOnly)
{
MP4VideoSyncEntry mp4VideoSyncEntry;
MP4AudioSyncEntry mp4AudioSyncEntry;
DWORD dwMP4VideosyncEntryAddr;
DWORD dwChunkSyncOffset;
DWORD dwChunkSizeAddr;
DWORD dwChunkSize;
DWORD dwAudioSyncEntryAddr;
MP4StreamSampleTableAddrEX mp4StreamSampleTableAddrEX;
if (TRUE == bVideoOnly)
{
dwMP4VideosyncEntryAddr = MP4_CALC_ENTRY_ADDRESS(MPEG4_PROCESSING_BUFF_ADDR, MP4_VIDEO_SYNC_ENTRY_SIZE, _ulMPEG4RequestedFrameIndex);
wai_sem(SEM_DRAM_ID);
I49_ReadDRAMData(dwMP4VideosyncEntryAddr,(UINT16*)&mp4VideoSyncEntry, MP4_VIDEO_SYNC_ENTRY_SIZE);
sig_sem(SEM_DRAM_ID);
dwChunkSyncOffset = mp4VideoSyncEntry.dwSyncChunkOffset;
_dwMP4VideoSyncOffset = dwChunkSyncOffset;
_dwMP4AudioSyncOffset = dwChunkSyncOffset;
}
else if (_ulMPEG4RequestedFrameIndex == 0)
{
dwChunkSyncOffset = _dwMP4FirstChunkOffset;
_dwMP4ChunkOffset = _dwMP4FirstChunkOffset;
_dwMP4VideoSyncOffset = dwChunkSyncOffset;
_dwMP4AudioSyncOffset = dwChunkSyncOffset;
_dwMP4ChunkSizeEntryIndex = 0UL;
}
else
{
dwMP4VideosyncEntryAddr = MP4_CALC_ENTRY_ADDRESS(MPEG4_PROCESSING_BUFF_ADDR, MP4_VIDEO_SYNC_ENTRY_SIZE, _ulMPEG4RequestedFrameIndex);
wai_sem(SEM_DRAM_ID);
I49_ReadDRAMData(dwMP4VideosyncEntryAddr,(UINT16*)&mp4VideoSyncEntry, MP4_VIDEO_SYNC_ENTRY_SIZE);
sig_sem(SEM_DRAM_ID);
sc_GetBytes(SC_MPEG4_AUDIO_SAMPLE_TABLE_ADDREX_BUFF_ADDR + (_mpeg4AudioCurrentDispIdx * SIZE_OF_MP4StreamSampleTableAddrEX_IN_DWORD),
0,SIZE_OF_MP4StreamSampleTableAddrEX,(BYTE*)&mp4StreamSampleTableAddrEX);
dwAudioSyncEntryAddr = MP4_CALC_ENTRY_ADDRESS(mp4SyncEntryStartAddr, MP4_AUDIO_SYNC_ENTRY_SIZE, _ulMPEG4RequestedFrameIndex);
wai_sem(SEM_DRAM_ID);
I49_ReadDRAMData(dwAudioSyncEntryAddr,(UINT16*)&mp4AudioSyncEntry, MP4_AUDIO_SYNC_ENTRY_SIZE);
sig_sem(SEM_DRAM_ID);
// DEC_MP4_SetFirstSkipBytes(mp4VideoSyncEntry.dwOffsetofChunk, mp4AudioSyncEntry.dwOffsetofChunk, 0);
if ((_mpeg4VideoStreamID != NO_STREAM) && (_mpeg4AudioStreamID != NO_STREAM))
{
dwChunkSyncOffset = min(mp4VideoSyncEntry.dwSyncChunkOffset, mp4AudioSyncEntry.dwSyncChunkOffset);
_dwMP4VideoSyncOffset = mp4VideoSyncEntry.dwSyncChunkOffset;
_dwMP4AudioSyncOffset = mp4AudioSyncEntry.dwSyncChunkOffset;
}
else if (_mpeg4VideoStreamID != NO_STREAM)
{
dwChunkSyncOffset = mp4VideoSyncEntry.dwSyncChunkOffset;
_dwMP4VideoSyncOffset = dwChunkSyncOffset;
_dwMP4AudioSyncOffset = dwChunkSyncOffset;
}
else if (_mpeg4AudioStreamID != NO_STREAM)
{
dwChunkSyncOffset = mp4AudioSyncEntry.dwSyncChunkOffset;
_dwMP4VideoSyncOffset = dwChunkSyncOffset;
_dwMP4AudioSyncOffset = dwChunkSyncOffset;
}
}
tr_printf(("First chunk Offset of Video: %8lx, Audio: %8lxn",_dwMP4VideoSyncOffset, _dwMP4AudioSyncOffset));
if ((dwChunkSyncOffset - _dwMP4FirstChunkOffset) <= (_dwMP4LastChunkEndOffset - dwChunkSyncOffset))
{
_dwMP4ChunkOffset = _dwMP4FirstChunkOffset;
_dwMP4ChunkSizeEntryIndex = 0UL;
#ifdef MP4_PACK_TRANSFER_CHUNK_SIZE
#if 0
if (TRUE == bMP4NeedPack)
dwChunkSizeAddr = MP4_CALC_ENTRY_ADDRESS(_dwMP4ChunkSizeStartAddr, MP4_PACK_CHUNK_SIZE_ENTRY_BUFF_SIZE, 0);
else
dwChunkSizeAddr = MP4_CALC_ENTRY_ADDRESS(_dwMP4ChunkSizeStartAddr, MP4_CHUNK_SIZE_ENTRY_BUFF_SIZE, 0);
#else
// Robin_0110_2005, reduce the seek time
if (TRUE == bMP4NeedPack)
dwChunkSizeAddr = MP4_CALC_ENTRY_ADDRESS(_dwMP4ChunkSizeStartAddr, MP4_PACK_CHUNK_SIZE_ENTRY_BUFF_SIZE, 3);
else
dwChunkSizeAddr = MP4_CALC_ENTRY_ADDRESS(_dwMP4ChunkSizeStartAddr, MP4_CHUNK_SIZE_ENTRY_BUFF_SIZE, 3);
while (TRUE)
{
dwChunkSize = _mp4CalculatePackTransferChunkSize(dwChunkSizeAddr, (DWORD*)&_MP4SharedBuff);
_dwMP4ChunkOffset += dwChunkSize;
if (_dwMP4ChunkOffset > dwChunkSyncOffset)
{
if (TRUE == bMP4NeedPack)
dwChunkSizeAddr += (MP4_PACK_CHUNK_SIZE_ENTRY_BUFF_SIZE2 - MP4_PACK_CHUNK_SIZE_ENTRY_BUFF_SIZE);
else
dwChunkSizeAddr += (MP4_CHUNK_SIZE_ENTRY_BUFF_SIZE2 - MP4_CHUNK_SIZE_ENTRY_BUFF_SIZE);
_dwMP4ChunkOffset -= dwChunkSize;
break;
}
_dwMP4ChunkSizeEntryIndex += MP4_CHUNK_SIZE_TABLE_BUFF_SIZE2;
if (TRUE == bMP4NeedPack)
dwChunkSizeAddr -= MP4_PACK_CHUNK_SIZE_ENTRY_BUFF_SIZE2;
else
dwChunkSizeAddr -= MP4_CHUNK_SIZE_ENTRY_BUFF_SIZE2;
}
#endif
_mp4LoadPackTransferChunkSize(dwChunkSizeAddr, (DWORD*)&_dwMP4ChunkSizeBuff);
#else
dwChunkSizeAddr = MP4_CALC_ENTRY_ADDRESS(_dwMP4ChunkSizeStartAddr, MP4_CHUNK_SIZE_ENTRY_BUFF_SIZE, 0);
wai_sem(SEM_DRAM_ID);
I49_ReadDRAMData(dwChunkSizeAddr,(UINT16*)&_dwMP4ChunkSizeBuff, MP4_CHUNK_SIZE_ENTRY_BUFF_SIZE);
sig_sem(SEM_DRAM_ID);
#endif
while (TRUE)
{
dwChunkSize = _dwMP4ChunkSizeBuff[MP4_CHUNK_SIZE_TABLE_BUFF_SIZE - (INT16)(_dwMP4ChunkSizeEntryIndex%MP4_CHUNK_SIZE_TABLE_BUFF_SIZE) - 1] >> 8;
_dwMP4ChunkOffset += dwChunkSize;
if (_dwMP4ChunkOffset > dwChunkSyncOffset)
break;
_dwMP4ChunkSizeEntryIndex++;
if (_dwMP4ChunkSizeEntryIndex % MP4_CHUNK_SIZE_TABLE_BUFF_SIZE == 0)
{
#ifdef MP4_PACK_TRANSFER_CHUNK_SIZE
if (TRUE == bMP4NeedPack)
dwChunkSizeAddr -= MP4_PACK_CHUNK_SIZE_ENTRY_BUFF_SIZE;
else
dwChunkSizeAddr -= MP4_CHUNK_SIZE_ENTRY_BUFF_SIZE;
_mp4LoadPackTransferChunkSize(dwChunkSizeAddr, (DWORD*)&_dwMP4ChunkSizeBuff);
#else
dwChunkSizeAddr -= MP4_CHUNK_SIZE_ENTRY_BUFF_SIZE;
wai_sem(SEM_DRAM_ID);
I49_ReadDRAMData(dwChunkSizeAddr,(UINT16*)&_dwMP4ChunkSizeBuff, MP4_CHUNK_SIZE_ENTRY_BUFF_SIZE);
sig_sem(SEM_DRAM_ID);
#endif
}
}
_dwMP4ChunkOffset -= dwChunkSize;
}
else
{
_dwMP4ChunkOffset = _dwMP4LastChunkEndOffset;
_dwMP4ChunkSizeEntryIndex = _dwMP4ChunkSizeEntryTotal -1;
#ifdef MP4_PACK_TRANSFER_CHUNK_SIZE
if (TRUE == bMP4NeedPack)
dwChunkSizeAddr = MP4_CALC_ENTRY_ADDRESS(_dwMP4ChunkSizeStartAddr, MP4_PACK_CHUNK_SIZE_ENTRY_BUFF_SIZE,
(_dwMP4ChunkSizeEntryIndex/MP4_CHUNK_SIZE_TABLE_BUFF_SIZE) );
else
dwChunkSizeAddr = MP4_CALC_ENTRY_ADDRESS(_dwMP4ChunkSizeStartAddr, MP4_CHUNK_SIZE_ENTRY_BUFF_SIZE,
(_dwMP4ChunkSizeEntryIndex/MP4_CHUNK_SIZE_TABLE_BUFF_SIZE) );
_mp4LoadPackTransferChunkSize(dwChunkSizeAddr, (DWORD*)&_dwMP4ChunkSizeBuff);
#else
dwChunkSizeAddr = MP4_CALC_ENTRY_ADDRESS(_dwMP4ChunkSizeStartAddr, MP4_CHUNK_SIZE_ENTRY_BUFF_SIZE,
(_dwMP4ChunkSizeEntryIndex/MP4_CHUNK_SIZE_TABLE_BUFF_SIZE) );
wai_sem(SEM_DRAM_ID);
I49_ReadDRAMData(dwChunkSizeAddr,(UINT16*)&_dwMP4ChunkSizeBuff, MP4_CHUNK_SIZE_ENTRY_BUFF_SIZE);
sig_sem(SEM_DRAM_ID);
#endif
while (TRUE)
{
dwChunkSize = _dwMP4ChunkSizeBuff[MP4_CHUNK_SIZE_TABLE_BUFF_SIZE - (INT16)(_dwMP4ChunkSizeEntryIndex%MP4_CHUNK_SIZE_TABLE_BUFF_SIZE) - 1] >> 8;
_dwMP4ChunkOffset -= dwChunkSize;
if (_dwMP4ChunkOffset <= dwChunkSyncOffset)
break;
if (_dwMP4ChunkSizeEntryIndex % MP4_CHUNK_SIZE_TABLE_BUFF_SIZE == 0)
{
#ifdef MP4_PACK_TRANSFER_CHUNK_SIZE
if (TRUE == bMP4NeedPack)
dwChunkSizeAddr += MP4_PACK_CHUNK_SIZE_ENTRY_BUFF_SIZE;
else
dwChunkSizeAddr += MP4_CHUNK_SIZE_ENTRY_BUFF_SIZE;
#if 1
// Robin_0110_2005, reduce the seek time
while (TRUE)
{
dwChunkSize = _mp4CalculatePackTransferChunkSize(dwChunkSizeAddr, (DWORD*)&_MP4SharedBuff);
_dwMP4ChunkOffset -= dwChunkSize;
if (_dwMP4ChunkOffset <= dwChunkSyncOffset)
{
_dwMP4ChunkOffset += dwChunkSize;
break;
}
_dwMP4ChunkSizeEntryIndex -= MP4_CHUNK_SIZE_TABLE_BUFF_SIZE2;
if (TRUE == bMP4NeedPack)
dwChunkSizeAddr += MP4_PACK_CHUNK_SIZE_ENTRY_BUFF_SIZE2;
else
dwChunkSizeAddr += MP4_CHUNK_SIZE_ENTRY_BUFF_SIZE2;
}
#endif
_mp4LoadPackTransferChunkSize(dwChunkSizeAddr, (DWORD*)&_dwMP4ChunkSizeBuff);
#else
dwChunkSizeAddr += MP4_CHUNK_SIZE_ENTRY_BUFF_SIZE;
wai_sem(SEM_DRAM_ID);
I49_ReadDRAMData(dwChunkSizeAddr,(UINT16*)&_dwMP4ChunkSizeBuff, MP4_CHUNK_SIZE_ENTRY_BUFF_SIZE);
sig_sem(SEM_DRAM_ID);
#endif
}
_dwMP4ChunkSizeEntryIndex--;
}
}
#ifdef PRINTF_MP4_TRANSFER_CHUNK_SIZE
dwTransferChunkOffset = _dwMP4ChunkOffset;
#endif
// search the correspond subtitle sample count
if (_mpeg4SubtitleType == INTERNAL_SUBT || _mpeg4SubtitleType == INTERNAL_SUBP)
{
DWORD dwSubtitleSampleEntryAddr;
MP4SubtitleSampleEntry mp4SubtitleSampleEntry[MP4_SUBTITLE_SAMPLE_ENTRY_BUFF_SIZE];
_dwMP4SubtitleSampleCount = 0UL;
_dwMP4SubtitleSampleStartTime = 0UL;
sc_GetBytes(SC_MPEG4_SUBTITLE_SAMPLE_TABLE_ADDREX_BUFF_ADDR + (_mpeg4SubtitleCurrentDispIdx * SIZE_OF_MP4StreamSampleTableAddrEX_IN_DWORD),
0,SIZE_OF_MP4StreamSampleTableAddrEX,(BYTE*)&mp4StreamSampleTableAddrEX);
_dwMP4SubtitleSampleAddr = mp4SyncEntryStartAddr;
for (_dwMP4SubtitleSampleCount=0;_dwMP4SubtitleSampleCount<mp4STSZEntryCount;_dwMP4SubtitleSampleCount++)
{
if (_dwMP4SubtitleSampleCount % MP4_SUBTITLE_SAMPLE_ENTRY_BUFF_SIZE == 0)
{
_dwMP4SubtitleSampleAddr -= MP4_SUBTITLE_SMAPLE_ENTRY_BUFF_SIZE;
wai_sem(SEM_DRAM_ID);
I49_ReadDRAMData(_dwMP4SubtitleSampleAddr,(UINT16*)&mp4SubtitleSampleEntry, MP4_SUBTITLE_SMAPLE_ENTRY_BUFF_SIZE);
sig_sem(SEM_DRAM_ID);
}
if (mp4SubtitleSampleEntry[MP4_SUBTITLE_SAMPLE_ENTRY_BUFF_SIZE - 1 - (_dwMP4SubtitleSampleCount % MP4_SUBTITLE_SAMPLE_ENTRY_BUFF_SIZE)].dwChunkOffset >= _dwMP4ChunkOffset)
break;
_dwMP4SubtitleSampleStartTime = mp4SubtitleSampleEntry[MP4_SUBTITLE_SAMPLE_ENTRY_BUFF_SIZE - 1 - (_dwMP4SubtitleSampleCount % MP4_SUBTITLE_SAMPLE_ENTRY_BUFF_SIZE)].dwSampleEndTime; // last sample
}
_dwMP4SubtitleSampleAddr += ((MP4_SUBTITLE_SAMPLE_ENTRY_BUFF_SIZE - 1 - (_dwMP4SubtitleSampleCount % MP4_SUBTITLE_SAMPLE_ENTRY_BUFF_SIZE)) * MP4_SUBTITLE_SMAPLE_ENTRY_SIZE);
_dwMP4SubtitleReadDRAMAddr = _dwMP4SubtitleWriteDRAMAddr = _mpeg4InternalSubtitleBufferStartAddr * 512UL;
if (_mpeg4SubtitleType == INTERNAL_SUBT)
mp4InitSubtitles();
}
}
static void _mp4TransferChunkSize(/*BOOL bFirst,*/ BOOL bWait)
{
DWORD dwChunkSizeAddr;
DWORD dwChunkSize;
DWORD dwChunkSizeAndId;
BYTE chunkID;
BYTE preChunkID;
BOOL bFirstGetChunk;
WORD wTransferLength;
DWORD mp4TransferChunkSizeBuff[MP4_TRANSFER_CHUNKSIZE_LENGTH];
// BOOL bLastChunkIsNotUsed;
BOOL bTransferChunkSizeFlag;
bTransferChunkSizeFlag = DEC_AVI_GetDemuxSharedBit( MP4_TRANSFER_STATUS_OFFSET, MP4_TRANSFER_CHUNK_SIZE_BIT);
if(TRUE == bWait)
{
while (TRUE == bTransferChunkSizeFlag)
bTransferChunkSizeFlag = DEC_AVI_GetDemuxSharedBit( MP4_TRANSFER_STATUS_OFFSET, MP4_TRANSFER_CHUNK_SIZE_BIT);
}
else
{
if (TRUE == bTransferChunkSizeFlag)
return;
}
preChunkID = MP4_NOT_USED_STREAM_ID;
chunkID = MP4_NOT_USED_STREAM_ID;
dwChunkSize = 0;
wTransferLength = 0;
// bLastChunkIsNotUsed = FALSE;
bFirstGetChunk = TRUE;
#ifdef PRINTF_MP4_TRANSFER_CHUNK_SIZE
{
dbg_printf(("ChunkSize Index : %lxn", _dwMP4ChunkSizeEntryIndex));
}
#endif
while (TRUE)
{
if (_dwMP4ChunkSizeEntryIndex > _dwMP4ChunkSizeEntryTotal)
break;
if (_dwMP4ChunkSizeEntryIndex == _dwMP4ChunkSizeEntryTotal)
{
mp4TransferChunkSizeBuff[wTransferLength++] = (((DWORD)preChunkID)<<24) + dwChunkSize;
_dwMP4ChunkSizeEntryIndex ++;
break;
}
dwChunkSizeAndId = _dwMP4ChunkSizeBuff[MP4_CHUNK_SIZE_TABLE_BUFF_SIZE - (INT16)(_dwMP4ChunkSizeEntryIndex%MP4_CHUNK_SIZE_TABLE_BUFF_SIZE) - 1];
preChunkID = chunkID;
chunkID = (BYTE)(dwChunkSizeAndId & 0xFF);
dwChunkSize += (dwChunkSizeAndId >> 8);
_dwMP4ChunkSizeEntryIndex++;
_dwMP4ChunkOffset += (dwChunkSizeAndId >> 8);
if (((chunkID == _mpeg4VideoStreamID) && (_dwMP4ChunkOffset <= _dwMP4VideoSyncOffset)) ||
((chunkID == _mpeg4AudioStreamID) && (_dwMP4ChunkOffset <= _dwMP4AudioSyncOffset)) /*||
((chunkID == _mpeg4SubtitleStreamID) && (_dwMP4ChunkOffset <= _dwMP4VideoSyncOffset))*/)
{
chunkID = MP4_NOT_USED_STREAM_ID;
}
if ((chunkID != _mpeg4VideoStreamID) && (chunkID != _mpeg4AudioStreamID) && (chunkID != _mpeg4SubtitleStreamID))
chunkID = MP4_NOT_USED_STREAM_ID;
if (FALSE == bFirstGetChunk)
{
if ((preChunkID != chunkID) || (dwChunkSize >= MP4_MAX_CHUNK_SIZE) || (_mpeg4VideoStreamID == NO_STREAM))
{
dwChunkSize -= (dwChunkSizeAndId >> 8);
mp4TransferChunkSizeBuff[wTransferLength++] = (((DWORD)preChunkID)<<24) + dwChunkSize;
//preChunkID = chunkID;
//dwChunkSize = (dwChunkSizeAndId >> 8);
_dwMP4ChunkSizeEntryIndex--;
_dwMP4ChunkOffset -= (dwChunkSizeAndId >> 8);
dwChunkSize = 0;
bFirstGetChunk = TRUE;
}
}
else
{
bFirstGetChunk = FALSE;
}
if (_dwMP4ChunkSizeEntryIndex % MP4_CHUNK_SIZE_TABLE_BUFF_SIZE == 0)
{
#ifdef MP4_PACK_TRANSFER_CHUNK_SIZE
if (TRUE == bMP4NeedPack)
dwChunkSizeAddr = MP4_CALC_ENTRY_ADDRESS(_dwMP4ChunkSizeStartAddr, MP4_PACK_CHUNK_SIZE_ENTRY_BUFF_SIZE,
(_dwMP4ChunkSizeEntryIndex/MP4_CHUNK_SIZE_TABLE_BUFF_SIZE));
else
dwChunkSizeAddr = MP4_CALC_ENTRY_ADDRESS(_dwMP4ChunkSizeStartAddr, MP4_CHUNK_SIZE_ENTRY_BUFF_SIZE,
(_dwMP4ChunkSizeEntryIndex/MP4_CHUNK_SIZE_TABLE_BUFF_SIZE));
_mp4LoadPackTransferChunkSize(dwChunkSizeAddr, (DWORD*)&_dwMP4ChunkSizeBuff);
#else
dwChunkSizeAddr = MP4_CALC_ENTRY_ADDRESS(_dwMP4ChunkSizeStartAddr, MP4_CHUNK_SIZE_ENTRY_BUFF_SIZE,
(_dwMP4ChunkSizeEntryIndex/MP4_CHUNK_SIZE_TABLE_BUFF_SIZE));
wai_sem(SEM_DRAM_ID);
I49_ReadDRAMData(dwChunkSizeAddr,(UINT16*)&_dwMP4ChunkSizeBuff, MP4_CHUNK_SIZE_ENTRY_BUFF_SIZE);
sig_sem(SEM_DRAM_ID);
#endif
}
if (wTransferLength >= MP4_TRANSFER_CHUNKSIZE_LENGTH)
break;
}
while (wTransferLength < MP4_TRANSFER_CHUNKSIZE_LENGTH)
mp4TransferChunkSizeBuff[wTransferLength++] = 0xFFFFFFFFUL;
#ifdef PRINTF_MP4_TRANSFER_CHUNK_SIZE
{
int i;
for (i=0;i<MP4_TRANSFER_CHUNKSIZE_LENGTH; i++)
{
dbg_printf(("Tansfer Chunk Offset: %8lx, Size: %8lx, Type: %2xn", dwTransferChunkOffset, mp4TransferChunkSizeBuff[i]&0xFFFFFFUL, mp4TransferChunkSizeBuff[i]>>24));
dwTransferChunkOffset += (mp4TransferChunkSizeBuff[i]&0xFFFFFFUL);
}
}
#endif
DEC_MP4_TransferChunkSize(wTransferLength,(DWORD*)&mp4TransferChunkSizeBuff);
return;
}
static void _mp4PrePlayProcessing(DWORD dwSamplingRate, UINT8 uiAudioSid,
UINT8 uiAudioSIDDecoder, UINT8 uiVideoSid, BOOL bClipStart, BOOL bScan)
{
BYTE Temp[4];
// for clear ADP internal Buffer
AuxCache_GetBytes(_dwMPEG4ClipStartLBA, 0, 4, &Temp[0]);
// for clear ADP APP buffer
_mp4ClearAPPBuffer();
#ifdef MP4_TANSFER_CHUNKSIZE_BY_FIFO
DEC_MP4_ChunkSizeFifoInit();
#endif
prePlayProcessing(dwSamplingRate, uiAudioSid, uiAudioSIDDecoder, uiVideoSid, bClipStart);
_mp4SetFirstSkipBytes(bScan);
return;
}
static void _mp4InitTransferChunkSize(BOOL bScan, DWORD dwVideoSampleSize )
{
if (FALSE == bScan)
{
_mp4GetChunkSizeEntryIndex(FALSE);
_mp4TransferChunkSize(/*TRUE,*/ TRUE);
_mp4TransferChunkSize(/*FALSE,*/ TRUE);
_mp4TransferChunkSize(/*FALSE,*/TRUE);
_mp4TransferChunkSize(/*FALSE,*/ TRUE);
_mp4TransferChunkSize(/*FALSE,*/TRUE);
_mp4TransferChunkSize(/*FALSE,*/TRUE);
_mp4TransferChunkSize(/*FALSE,*/TRUE);
_mp4TransferChunkSize(/*FALSE,*/TRUE);
DEC_MP4_UnsetFlashCardNotNeedCheck();
#ifdef MP4_TANSFER_CHUNKSIZE_BY_FIFO
_mp4TransferChunkSizeByFifo();
#endif
}
else
{
WORD wTransferLength = 0;
DWORD mp4TransferChunkSizeBuff[MP4_TRANSFER_CHUNKSIZE_LENGTH];
mp4TransferChunkSizeBuff[wTransferLength++] = (((DWORD)_mpeg4VideoStreamID) << 24) + dwVideoSampleSize;
#ifdef SUPPORT_FLASH_CARD
if(IS_PLAYING_CARD)
{
DWORD dwChunkSizeAndId;
BYTE chunkID;
DWORD dwChunkSize;
BOOL bFirstGetChunk = TRUE;
MP4VideoSyncEntry mp4VideoSyncEntry;
DWORD dwMP4VideosyncEntryAddr;
DWORD dwChunkSizeAddr;
UINT8 chunkCount = 0;
_mp4GetChunkSizeEntryIndex(TRUE);
while (TRUE)
{
if (_dwMP4ChunkSizeEntryIndex >= _dwMP4ChunkSizeEntryTotal)
break;
dwChunkSizeAndId = _dwMP4ChunkSizeBuff[MP4_CHUNK_SIZE_TABLE_BUFF_SIZE - (INT16)(_dwMP4ChunkSizeEntryIndex%MP4_CHUNK_SIZE_TABLE_BUFF_SIZE) - 1];
chunkID = (BYTE)(dwChunkSizeAndId & 0xFF);
dwChunkSize = (dwChunkSizeAndId >> 8);
_dwMP4ChunkSizeEntryIndex++;
if (chunkID != _mpeg4VideoStreamID)
chunkID = MP4_NOT_USED_STREAM_ID;
if (bFirstGetChunk)
{
dwMP4VideosyncEntryAddr = MP4_CALC_ENTRY_ADDRESS(MPEG4_PROCESSING_BUFF_ADDR, MP4_VIDEO_SYNC_ENTRY_SIZE, _ulMPEG4RequestedFrameIndex);
wai_sem(SEM_DRAM_ID);
I49_ReadDRAMData(dwMP4VideosyncEntryAddr,(UINT16*)&mp4VideoSyncEntry, MP4_VIDEO_SYNC_ENTRY_SIZE);
sig_sem(SEM_DRAM_ID);
dwChunkSize -= (mp4VideoSyncEntry.dwOffsetofChunk + mp4VideoSyncEntry.dwSyncSampleSize);
bFirstGetChunk = FALSE;
}
if (dwChunkSize ==0)
continue;
mp4TransferChunkSizeBuff[wTransferLength++] = (((DWORD)chunkID)<<24) + dwChunkSize; // chunk id in MSB[31-24]
if (chunkID == _mpeg4VideoStreamID && chunkCount >2)
break;
chunkCount++;
if (_dwMP4ChunkSizeEntryIndex % MP4_CHUNK_SIZE_TABLE_BUFF_SIZE == 0)
{
#ifdef MP4_PACK_TRANSFER_CHUNK_SIZE
if (TRUE == bMP4NeedPack)
dwChunkSizeAddr = MP4_CALC_ENTRY_ADDRESS(_dwMP4ChunkSizeStartAddr, MP4_PACK_CHUNK_SIZE_ENTRY_BUFF_SIZE,
(_dwMP4ChunkSizeEntryIndex/MP4_CHUNK_SIZE_TABLE_BUFF_SIZE));
else
dwChunkSizeAddr = MP4_CALC_ENTRY_ADDRESS(_dwMP4ChunkSizeStartAddr, MP4_CHUNK_SIZE_ENTRY_BUFF_SIZE,
(_dwMP4ChunkSizeEntryIndex/MP4_CHUNK_SIZE_TABLE_BUFF_SIZE));
_mp4LoadPackTransferChunkSize(dwChunkSizeAddr, (DWORD*)&_dwMP4ChunkSizeBuff);
#else
dwChunkSizeAddr = MP4_CALC_ENTRY_ADDRESS(_dwMP4ChunkSizeStartAddr, MP4_CHUNK_SIZE_ENTRY_BUFF_SIZE,
(_dwMP4ChunkSizeEntryIndex/MP4_CHUNK_SIZE_TABLE_BUFF_SIZE));
wai_sem(SEM_DRAM_ID);
I49_ReadDRAMData(dwChunkSizeAddr,(UINT16*)&_dwMP4ChunkSizeBuff, MP4_CHUNK_SIZE_ENTRY_BUFF_SIZE);
sig_sem(SEM_DRAM_ID);
#endif
}
if (wTransferLength >= MP4_TRANSFER_CHUNKSIZE_LENGTH)
break;
}
}
else
#endif
mp4TransferChunkSizeBuff[wTransferLength++] = 0xFF000000UL + 16*2048UL;
while (wTransferLength < MP4_TRANSFER_CHUNKSIZE_LENGTH)
mp4TransferChunkSizeBuff[wTransferLength++] = 0xFFFFFFFFUL;
DEC_MP4_TransferChunkSize(wTransferLength,(DWORD*)&mp4TransferChunkSizeBuff);
DEC_MP4_SetFlashCardNotNeedCheck();
}
}
/*
static void _mp4GetTransferTimes()
{
MP4StreamSampleTableAddrEX mp4StreamSampleTableAddrEX;
DWORD dwSamplesPre200ms;
_wMP4TransferChunkSizeTimes = 0;
sc_GetBytes(SC_MPEG4_VIDEO_SAMPLE_TABLE_ADDREX_BUFF_ADDR,
0,SIZE_OF_MP4StreamSampleTableAddrEX,(BYTE*)&mp4StreamSampleTableAddrEX);
dwSamplesPre200ms = _mpeg4VideoRate / (_mpeg4VideoScale * MP4_TRANSFER_CHUNKSIZE_TIMES_IN_SEC);
dwSamplesPre200ms++;
_wMP4TransferChunkSizeTimes += (WORD)((dwSamplesPre200ms * mp4STCOEntryCount) / mp4STSZEntryCount);
_wMP4TransferChunkSizeTimes ++;
sc_GetBytes(SC_MPEG4_AUDIO_SAMPLE_TABLE_ADDREX_BUFF_ADDR + (_mpeg4AudioCurrentDispIdx * SIZE_OF_MP4StreamSampleTableAddrEX_IN_DWORD),
0,SIZE_OF_MP4StreamSampleTableAddrEX,(BYTE*)&mp4StreamSampleTableAddrEX);
dwSamplesPre200ms = _mpeg4AudioRate / (_mpeg4AudioScale * MP4_TRANSFER_CHUNKSIZE_TIMES_IN_SEC);
dwSamplesPre200ms++;
_wMP4TransferChunkSizeTimes += (WORD)((dwSamplesPre200ms * mp4STCOEntryCount) / mp4STSZEntryCount);
_wMP4TransferChunkSizeTimes ++;
}
*/
static BOOL _mp4Scan(INT8 iIndexIncrement, BOOL bContinue)
{
DWORD dwStartLBA;
WORD wClipStartOffset;
WORD wClipEndOffset;
ULONG ulBlocksCnt;
MP4VideoSyncEntry mp4VideoSyncEntry;
DWORD dwVideoSyncSampleNum, dwSyncSampleOffset;
dbg_printf(("_mp4Scan()n"));
/* If we are not yet in scan mode, calculate the entry in the index corresponding to the current time */
if (FALSE == bContinue)
{
if(FALSE == _mp4GetAdjacentIFrames(_uiMPEG4StartTime,&dwVideoSyncSampleNum, &dwSyncSampleOffset))
{
dbg_printf(("WARNNING: _mp4Scan() Failed [1]n"));
return FALSE;
}
}
/* Check whether we scanned the whole idx table */
if ( (((INT32)_ulMPEG4RequestedFrameIndex + (INT32)iIndexIncrement) >= _uiMPEG4NextIndexEntry) ||
(((INT32)_ulMPEG4RequestedFrameIndex + (INT32)iIndexIncrement) < 0) )
{
DEC_AVI_EnableFinishCB(FALSE);
ie_send(IE_CORE_CDNAV_FINISHED);
return TRUE;
}
/* Calculate the next entry to be played */
_ulMPEG4RequestedFrameIndex = (UINT32)((INT32)_ulMPEG4RequestedFrameIndex + (INT32)iIndexIncrement);
wai_sem(SEM_DRAM_ID);
I49_ReadDRAMData(MP4_CALC_ENTRY_ADDRESS(MPEG4_PROCESSING_BUFF_ADDR, (sizeof(MP4VideoSyncEntry)/2), _ulMPEG4RequestedFrameIndex),
(UINT16*)&mp4VideoSyncEntry, sizeof(MP4VideoSyncEntry)/2);
sig_sem(SEM_DRAM_ID);
tr_printf(("nVideo Sync SampleNumber: %lx, ChunkOffset: %lx, OffsetOfChunk: %lx, SampleSize %lxnn",
mp4VideoSyncEntry.dwSyncSampleNumber, mp4VideoSyncEntry.dwSyncChunkOffset, mp4VideoSyncEntry.dwOffsetofChunk, mp4VideoSyncEntry.dwSyncSampleSize));
/* Calculate the playback addresses */
dwStartLBA = _dwMPEG4ClipStartLBA + ((mp4VideoSyncEntry.dwSyncChunkOffset + mp4VideoSyncEntry.dwOffsetofChunk)>> 11);
wClipStartOffset = (WORD)( (mp4VideoSyncEntry.dwSyncChunkOffset + mp4VideoSyncEntry.dwOffsetofChunk) % LOGICAL_BLOCK_SIZE);
ulBlocksCnt = (wClipStartOffset + mp4VideoSyncEntry.dwSyncSampleSize + LOGICAL_BLOCK_SIZE - 1) / LOGICAL_BLOCK_SIZE;
ulBlocksCnt += 16;
wClipEndOffset = (WORD)((wClipStartOffset + mp4VideoSyncEntry.dwSyncSampleSize) % LOGICAL_BLOCK_SIZE);
if (0 == wClipEndOffset)
{
wClipEndOffset = 2048;
}
/* Calculate the start time */
_uiMPEG4StartTime = caclTimeOfFrame(mp4VideoSyncEntry.dwSyncSampleNumber ,_mpeg4VideoRate, _mpeg4VideoScale);
if (FALSE == bContinue)
{
/* Scanning just started, re initialize the decoder */
DWORD dwSampleRate;
UINT8 uiAudioSID;
UINT8 uiAudioSIDDecoder;
determineAudioInfo(&uiAudioSID, &uiAudioSIDDecoder, &dwSampleRate);
_mp4PrePlayProcessing(dwSampleRate, NO_STREAM, NO_STREAM, 0xFF, FALSE, TRUE);
API_ADPSetMp3_Throw_Out_Cntr(0);
/* Signal to the DVP the decision */
DEC_AVI_SetIOnly(TRUE);
DEC_AVI_SetIPOnly(FALSE);
DEC_AVI_ResetDemuxStatus();
DEC_AVI_SetStartVideoChunks(mp4VideoSyncEntry.dwSyncSampleNumber);
/* The order of the calls to the functions should not be changed! */
DEC_AVI_SetPlaybackParams(wClipStartOffset, wClipEndOffset, _uiMPEG4StartTime, 0, 0);
PE_Clips_SetPlaybackRange(dwStartLBA, ulBlocksCnt, UNLIMITED_FILE_SIZE);
_mp4InitTransferChunkSize(TRUE, mp4VideoSyncEntry.dwSyncSampleSize);
if (!PE_Clips_Playback_Sectors(DRVCF_CDSPEED_1X | DRVF_PLAY_CD_AV_DATA, dwStartLBA, ulBlocksCnt))
{
dbg_printf(("FATAL: _asfScan() Failed [2]n"));
return FALSE;
}
}
else
{
#ifdef SUPPORT_FLASH_CARD
if(IS_PLAYING_CARD)
{
DWORD dwSampleRate;
UINT8 uiAudioSID;
UINT8 uiAudioSIDDecoder;
determineAudioInfo(&uiAudioSID, &uiAudioSIDDecoder, &dwSampleRate);
prePlayProcessing(dwSampleRate, NO_STREAM, NO_STREAM, 0xFF, FALSE);
_mp4SetFirstSkipBytes(TRUE);
}
else
#endif
/* Stopping the current drive playback */
drv_abort_play();
/* Signal to the DVP the decision */
DEC_AVI_SetIOnly(TRUE);
DEC_AVI_SetIPOnly(FALSE);
DEC_AVI_ResetDemuxStatus();
DEC_AVI_SetStartVideoChunks(mp4VideoSyncEntry.dwSyncSampleNumber);
/* Set the next playback request to the decoder and to the drive */
DEC_AVI_SetPlaybackParams(wClipStartOffset, wClipEndOffset, _uiMPEG4StartTime, 0, 0);
PE_Clips_SetPlaybackRange(dwStartLBA, ulBlocksCnt, UNLIMITED_FILE_SIZE);
_mp4InitTransferChunkSize(TRUE, mp4VideoSyncEntry.dwSyncSampleSize);
if (!PE_Clips_Playback_Sectors(DRVCF_CDSPEED_1X | DRVF_PLAY_CD_AV_DATA, dwStartLBA, ulBlocksCnt))
{
dbg_printf(("WARNNING: _asfScan() Failed [3]n"));
return FALSE;
}
}
/* Install call back from the decoder */
DEC_AVI_EnableFinishCB(TRUE);
return TRUE;
}
static void _mp4ClearAPPBuffer(void)
{
#define APP_ACC_OFFSET 0x1800 // in word
#define APP_ACC_SIZE 0xC800 // in word
DWORD dwAppStartAddr = REAL_APP_START_ADDR + APP_ACC_OFFSET;
DWORD dwAppEndAddr;
WORD ClearBuf[32] = {0};
dwAppEndAddr = dwAppStartAddr + APP_ACC_SIZE;
while(dwAppStartAddr < dwAppEndAddr)
{
wai_sem(SEM_DRAM_ID);
I49_WriteDRAMData(dwAppStartAddr,(UINT16*)(&ClearBuf[0]), 32);
sig_sem(SEM_DRAM_ID);
dwAppStartAddr += 32;
}
}
static void _mp4ChapterProcess(DWORD dwStartAddr)
{
MPEG4ChapterEntry mpeg4ChapterEntry;
DWORD dwEntryCount;
UINT16 uiChapterNameOffset;
UINT16 uiChapterNameLen;
UINT16 uiUnicodeNameLen;
QWORD qwTime;
UINT32 ulTime;
BYTE TempBuff[10];
WORD unicodeBuff[10];
WORD wLastUnicode;
DWORD dwOffset;
WORD wVersion;
DWORD dwChapterDRAMAddr;
if (_bMPEG4IsIndexProcessed == TRUE)
return;
_mpeg4ChapterAvailableNum = 0;
if (0UL == _dwMP4ChapterOffset)
return;
else
dwOffset = _dwMP4ChapterOffset;
if (FALSE == AuxCache_GetBytes(dwStartAddr, dwOffset, (WORD)9, &TempBuff[0]))
{
dbg_printf(("_mp4StreamsInfoProcessing(): AuxCache_GetBytes() Fail[3] n"));
return;
}
dwOffset += 9;
wVersion = (WORD)TempBuff[0];
dwEntryCount = _toBe32(&TempBuff[5]);
// _mpeg4ChapterAvailableNum = dwEntryCount;
_dwMP4ChapterDRAMStartAddr = _dwMPEG4ProcessingEndAddr;
dwChapterDRAMAddr = _dwMP4ChapterDRAMStartAddr;
if (wVersion == 1)
uiChapterNameOffset = 9;
else
uiChapterNameOffset = 5;
while(dwEntryCount--)
{
if (FALSE == AuxCache_GetBytes(dwStartAddr, dwOffset, uiChapterNameOffset, &TempBuff[0]))
{
dbg_printf(("_mp4StreamsInfoProcessing(): AuxCache_GetBytes() Fail[3] n"));
return;
}
dwOffset += uiChapterNameOffset;
if (wVersion == 1)
{
qwTime[1] = _toBe32(&TempBuff[0]);
qwTime[0] = _toBe32(&TempBuff[4]);
ulTime = qwTimeDiv10000(qwTime); // in ms
ulTime /= 1000UL;
}
else
{
ulTime = _toBe32(&TempBuff[0]);
ulTime /= 10000000UL;
}
mpeg4ChapterEntry.uiChapterTime = (WORD)ulTime;
uiChapterNameLen = TempBuff[uiChapterNameOffset-1];
uiUnicodeNameLen = 0;
wLastUnicode = 0;
while (uiChapterNameLen > 0)
{
UINT16 uiBufferSize;
UINT16 uiUnicodeBufferSize;
UINT16 uiUnicodeBufferOffset;
uiBufferSize = min(uiChapterNameLen, 10);
if (FALSE == AuxCache_GetBytes(dwStartAddr, dwOffset, uiChapterNameOffset, &TempBuff[0]))
{
dbg_printf(("_mp4StreamsInfoProcessing(): AuxCache_GetBytes() Fail[3] n"));
return;
}
uiUnicodeBufferSize =0;
UTF8ToUnicode(TempBuff, unicodeBuff, uiBufferSize, &wLastUnicode, &uiUnicodeBufferSize);
dwOffset += uiBufferSize;
uiChapterNameLen -= uiBufferSize;
uiUnicodeBufferOffset = 0;
while(uiUnicodeBufferSize--)
{
mpeg4ChapterEntry.wChapterName[uiUnicodeNameLen++] = unicodeBuff[uiUnicodeBufferOffset++];
if (uiUnicodeNameLen>=(MPEG4_CHAPTER_NAME_LENGTH-2))
break;
}
}
mpeg4ChapterEntry.wChapterName[uiUnicodeNameLen] = 0; // end flag
// store chapter entry
dwChapterDRAMAddr -= (sizeof(MPEG4ChapterEntry)/2);
wai_sem(SEM_DRAM_ID);
I49_WriteDRAMData(dwChapterDRAMAddr,(UINT16*)&mpeg4ChapterEntry, (sizeof(MPEG4ChapterEntry)/2));
sig_sem(SEM_DRAM_ID);
_mpeg4ChapterAvailableNum ++;
}
_dwMPEG4ProcessingEndAddr = dwChapterDRAMAddr;
_dwMPEG4ProcessingEndAddr = (_dwMPEG4ProcessingEndAddr>>9)<<9;
dbg_printf(("MP4 Chapter Number: %dn", _mpeg4ChapterAvailableNum));
}
static void _mp4ChapterInit(void)
{
DWORD dwDRAMAddr;
MPEG4ChapterEntry mpeg4ChapterEntry;
_uiMP4ChapterStartTime =0;
_uiMP4ChapterEndTime = 0;
_mpeg4ChapterCurrentDispIdx = 0;
if (_mpeg4ChapterAvailableNum <= 1)
{
_uiMP4ChapterEndTime = 0xFFFFU;
return;
}
dwDRAMAddr = _dwMP4ChapterDRAMStartAddr - ((_mpeg4ChapterCurrentDispIdx+1) * sizeof(MPEG4ChapterEntry)/2);
wai_sem(SEM_DRAM_ID);
I49_ReadDRAMData(dwDRAMAddr,(UINT16*)&mpeg4ChapterEntry, (sizeof(MPEG4ChapterEntry)/2));
sig_sem(SEM_DRAM_ID);
_uiMP4ChapterStartTime = mpeg4ChapterEntry.uiChapterTime;
if (_mpeg4ChapterCurrentDispIdx < (_mpeg4ChapterAvailableNum -1))
{
dwDRAMAddr -= (sizeof(MPEG4ChapterEntry)/2);
wai_sem(SEM_DRAM_ID);
I49_ReadDRAMData(dwDRAMAddr,(UINT16*)&mpeg4ChapterEntry, (sizeof(MPEG4ChapterEntry)/2));
sig_sem(SEM_DRAM_ID);
_uiMP4ChapterEndTime = mpeg4ChapterEntry.uiChapterTime;
}
else
{
_uiMP4ChapterEndTime = 0xFFFFU;
}
}
static void _mp4ChapterRefresh(void)
{
DWORD dwDRAMAddr;
MPEG4ChapterEntry mpeg4ChapterEntry;
if (_uiMPEG4StartTime > _uiMP4ChapterEndTime)
{
_mpeg4ChapterCurrentDispIdx ++;
if (_mpeg4ChapterCurrentDispIdx < (_mpeg4ChapterAvailableNum -1))
{
dwDRAMAddr = _dwMP4ChapterDRAMStartAddr - ((_mpeg4ChapterCurrentDispIdx+2) * sizeof(MPEG4ChapterEntry)/2);
wai_sem(SEM_DRAM_ID);
I49_ReadDRAMData(dwDRAMAddr,(UINT16*)&mpeg4ChapterEntry, (sizeof(MPEG4ChapterEntry)/2));
sig_sem(SEM_DRAM_ID);
_uiMP4ChapterStartTime = _uiMP4ChapterEndTime;
_uiMP4ChapterEndTime = mpeg4ChapterEntry.uiChapterTime;
}
else
{
_uiMP4ChapterStartTime = _uiMP4ChapterEndTime;
_uiMP4ChapterEndTime = 0xFFFFU;
}
}
if ((_uiMPEG4StartTime+1) < _uiMP4ChapterStartTime)
{
if (_mpeg4ChapterCurrentDispIdx > 0)
{
_mpeg4ChapterCurrentDispIdx --;
dwDRAMAddr = _dwMP4ChapterDRAMStartAddr - ((_mpeg4ChapterCurrentDispIdx+1) * sizeof(MPEG4ChapterEntry)/2);
wai_sem(SEM_DRAM_ID);
I49_ReadDRAMData(dwDRAMAddr,(UINT16*)&mpeg4ChapterEntry, (sizeof(MPEG4ChapterEntry)/2));
sig_sem(SEM_DRAM_ID);
_uiMP4ChapterEndTime = _uiMP4ChapterStartTime;
_uiMP4ChapterStartTime = mpeg4ChapterEntry.uiChapterTime;
}
else
{
// _uiMP4ChapterEndTime = _uiMP4ChapterStartTime;
_uiMP4ChapterStartTime = 0;
}
}
}
#ifdef PATCH_VIDEO_NOT_B
///////////////////////////////////////////////////////////////////////////
// Function name : _detectBVOP
// Purpose : Detect if B-VOP exist
// Input Parameters :
// Return type : if B-VOP exist, return TRUE. if not exist, return FALSE
// Description :
///////////////////////////////////////////////////////////////////////////
static BOOL _mp4DetectBVOP(void)
{
//DWORD dwStartLBA,dwClipStartOffset;
//DWORD pdwOffset;
//BYTE videoStreamID1[FOURCC_FIELD_LENGTH], videoStreamID2[FOURCC_FIELD_LENGTH];
BYTE videoHeaderBuff[64]; // 64 is enough
WORD wVideoHeaderSize;
BYTE videoObjectType;
int i,j;
if (_mpeg4VideoCodec== DIVX_3_11 ||
_mpeg4VideoCodec == DIVX_4_12 ||
_mpeg4VideoCodec == MP43 ||
_mpeg4VideoCodec == DIVX_UNKNOWN)
{
dbg_printf(("Video isn't B encoded.n"));
return FALSE;
}
wVideoHeaderSize = 64;
if (_mpeg4VideoHeaderDataLength > 0) // always in MP4
{
wVideoHeaderSize = min(wVideoHeaderSize,MPEG4_VIDEO_HEADER_CACHE_SIZE);
wai_sem(SEM_DRAM_ID);
I49_ReadDRAMData(SC_MPEG4_VIDEO_HEADER_DATA_ADDR, &videoHeaderBuff, wVideoHeaderSize);
sig_sem(SEM_DRAM_ID);
}
else
{
dbg_printf(("Video header data is in the moive data.n"));
return FALSE;
}
for (i=0; i<(wVideoHeaderSize -4);i++)
{
if(videoHeaderBuff[i] != 0)
continue;
if(videoHeaderBuff[i+1] != 0)
continue;
if(videoHeaderBuff[i+2] == 1)
{
if ((videoHeaderBuff[i+3] >= 20) && (videoHeaderBuff[i+3] <= 0x2F)) // video obejct layer start code
{
break;
}
}
}
if (i >= (wVideoHeaderSize -4))
return FALSE;
i += 4;
j=0;
j+=1;// random_accessible_vol
videoObjectType = (videoHeaderBuff[i+(j+1)/8]<<1) + (videoHeaderBuff[i+1+(j+1)/8]>>7);
dbg_printf(("Video object 0x%xn",videoObjectType));
j+=8;//video_object_type_indication
if ((videoHeaderBuff[i+(j+1)/8] >> (7-(j%8)) & 0x1) == 0x1)
j+=7;
j+=1;
if ((videoHeaderBuff[i+(j+1)/8] >> (7-4 -(j%8)) & 0xF) == 0xF) //
j+=16;
j+=4;
if ((videoHeaderBuff[i+(j+1)/8] >> (7-(j%8)) & 0x1) == 0x1)
{
j+=1;
j+=2;
if ((videoHeaderBuff[i+(j+1)/8] >> (7-(j%8)) & 0x1) == 0x1) // low delay
{
dbg_printf(("Video isn't B encoded.n"));
return FALSE;
}
else
return TRUE;
}
else
{
if(videoObjectType == 0x01) // simple
return FALSE;
else if (videoObjectType == 0x11) // advanced simple
return TRUE;
else
return FALSE;
}
}
#endif
/////////////////////////////////////////////////////////////////////////////
// Public Services
BOOL MP4Clip_isKindOf(LPCWSTR i_pszFilename)
{
return GenericClip_isKindOf(i_pszFilename, CLIP_VALID_EXTENSIONS(MP4));
}
void MP4Clip_construct(struct Clip_TAG *o_pThis, const FindData *i_pFileInfo)
{
GenericClip_construct(o_pThis, i_pFileInfo);
o_pThis->m_pConstAttr = &CLIP_CONST_ATTR(MP4);
}
#pragma argsused
BOOL MP4Clip_getExtendedInfo(const struct Clip_TAG *i_pThis,
void *o_pExtInfoContainer)
{
return FALSE;
}
#pragma argsused
BOOL MP4Clip_play(Clip *i_pThis, const ClipMarker *i_pResumeMarker, BOOL bCacheOnly)
{
DWORD dwClipStartAddr = (i_pThis->m_cfiInfo).dwFileLocation, dwStartLBA;
WORD wClipStartOffset;
WORD wClipEndOffset;
ULONG ulBlocksCnt;
UINT8 uiAudioSID, uiAudioSIDDecoder;
DWORD dwSamplingRate;
DWORD dwMdatSize;
DWORD dwVideoSyncSampleNum, dwSyncSampleOffset;
UINT32 ulStartTime1, ulStartTime2;
UINT32 ulEndTime1, ulEndTime2;
dbg_printf(("Playing MP4 filen"));
Logo_selectSource(eFrame);
#if defined(NO_AUTO_PLAY_FOR_CLIPS) || defined(NO_AUTO_PLAY_ONLY_FOR_DVIX)
if (g_patch_4_auto_play)
{
g_patch_4_auto_play = FALSE;
return TRUE;
}
#endif
_uiMPEG4TotalDVPIdleTime = 0;
/* Check if the ASF info should be acquired */
if (NULL == i_pResumeMarker)
{
_bMPEG4PauseToSlow = FALSE;
_mpeg4SubtitleCurrentDispIdx = 0;
_mpeg4AudioCurrentDispIdx = 0;
_mpeg4ChapterCurrentDispIdx = 0;
change_pallet = TRUE;
_bMPEG4WasClockEnabled = FALSE;
if (_uiMPEG4ProcessedFileAddr != dwClipStartAddr) //Don't process index if already processed.
_bMPEG4IsIndexProcessed = FALSE;
_iMPEG4CurrentScanningMode = 0;
_uiMPEG4NumOfDecodedChunksMemory = 0;
_bMPEG4TrickModeOn = TRUE;
_uiMPEG4StartTime = 0;
// _dwMPEG4ProcessingEndAddr = MPEG4_PROCESSING_BUFF_ADDR;
_ulMPEG4RequestedFrameIndex = 0UL;
// Clear shared RAM offsets that will be used
DEC_AVI_ClearSharedOffset(0);
DEC_AVI_ClearSharedOffset(1);
// RB_1124_2004, add "mpeg4 loading..." display
ie_send(IE_UI_MPEG4_LOADING_START);
ulStartTime2 = ulStartTime1 = (gen_timer()/1000UL);
if (FALSE == _mp4InfoProcessing(dwClipStartAddr,(i_pThis->m_cfiInfo).cbFileSize))
{
Logo_selectSource(eStartup);
Logo_display();
ie_send(IE_UI_CLIPS_CLEAR_UI);
// Robin_0125_2005, display more info
if (bMP4DRMDisable)
core_report_error( IE_UI_REPORT_ERROR, (void *) CLIPSNAV_ERR_MP4_DRMDISABLE_UOP );
else if (bMP4UnSupportProfile)
core_report_error( IE_UI_REPORT_ERROR, (void *) CLIPSNAV_ERR_MP4_UNSUPPORTPROFILE_UOP );
else
core_report_error( IE_UI_REPORT_ERROR, (void *) CLIPSNAV_ERR_WRONGFILE_UOP );
tr_printf(("FATAL: MP4Clip_play() Failed [1]n"));
usleep(300000UL); // ensure UI accept the event
// <<< Stivenz_0223_2005: If current chapter is unsupported then goto next.
#ifdef D_MP4_SKIP_UNSUPPORTED_CHAPTER
DEC_CacheInit(); /* should clear the data which was cached by last unsupport chapter*/
#endif
return FALSE;
}
ulEndTime1 = (gen_timer()/1000UL);
tr_printf(("_mp4InfoProcessing() total time : %ld msecn", ulEndTime1-ulStartTime1));
// if (NO_STREAM == _mpeg4VideoStreamID)
// {
// tr_printf(("FATAL: MP4Clip_play() Failed [2]n"));
// return FALSE;
// }
ie_send(IE_UI_MPEG4_LOADING_START);
ulStartTime1 = (gen_timer()/1000UL);
if (FALSE == _mp4SampleTableProcessing(dwClipStartAddr))
{
tr_printf(("MP4Clip_play(): _mp4SampleTableProcessing() Fail[] n"));
ie_send(IE_UI_CLIPS_CLEAR_UI);
return FALSE;
}
ulEndTime1 = (gen_timer()/1000UL);
tr_printf(("_mp4SampleTableProcessing() total time : %ld msecn",ulEndTime1-ulStartTime1));
// _bMPEG4TrickModeOn = TRUE;
ie_send(IE_UI_MPEG4_LOADING_START);
ulStartTime1 = (gen_timer()/1000UL);
if (FALSE == _mp4ChunkSizeProcessing())
{
tr_printf(("MP4Clip_play(): _mp4ChunkSizeProcessing() Fail[] n"));
ie_send(IE_UI_CLIPS_CLEAR_UI);
return FALSE;
}
ulEndTime1 = (gen_timer()/1000UL);
tr_printf(("_mp4ChunkSizeProcessing() total time : %ld msecn",ulEndTime1-ulStartTime1));
_mp4ChapterProcess(dwClipStartAddr);
#ifdef USE_AUX_SUBTITLES
if (_bMPEG4IsIndexProcessed == FALSE)
_mpeg4ExternalSubtitleAddr = _dwMPEG4ProcessingEndAddr;
#endif
_uiMPEG4ProcessedFileAddr = dwClipStartAddr;
_bMPEG4IsIndexProcessed = TRUE;
#ifdef AVI_FF_NO_INDEX
DEC_AVI_SetIndex(_bMPEG4TrickModeOn);
#endif
#ifdef USE_AUX_SUBTITLES
initAuxSubtitles(&(i_pThis->m_cfiInfo), _mpeg4VideoScale,_mpeg4VideoRate);
AuxCache_GetFileTerminate();
#endif //USE_AUX_SUBTITLES
// always first subtitle stream
sc_GetBytes(SC_MPEG4_SUBTITLE_STREAM_INFO_ADDR,
0,
SIZE_OF_SUBTITLE_STREAM_INFO,
(BYTE*)&_mpeg4SubtitleStreamInfo
);
if (_mpeg4SubtitleAvailableNum == 0)
_mpeg4SubtitleStreamID = NO_STREAM;
{
UINT16 uiAudioIdx;
UINT16 uiAudioNum = 0;
for (uiAudioIdx=0;uiAudioIdx<_mpeg4AudioAvailableNum;uiAudioIdx++)
{
sc_GetBytes(SC_MPEG4_AUDIO_STREAM_INFO_ADDR,
(uiAudioIdx * SIZE_OF_AUDIO_STREAM_INFO),
SIZE_OF_AUDIO_STREAM_INFO,
(BYTE*)&_mpeg4AudioStreamInfo
);
if (_mpeg4AudioCodec != AUDIO_UNKNOWN)
{
if (uiAudioIdx > uiAudioNum)
{
sc_SetBytes(SC_MPEG4_AUDIO_STREAM_INFO_ADDR,
(uiAudioNum * SIZE_OF_AUDIO_STREAM_INFO),
SIZE_OF_AUDIO_STREAM_INFO,
(BYTE*)&_mpeg4AudioStreamInfo
);
}
uiAudioNum++;
}
}
_mpeg4AudioAvailableNum = uiAudioNum;
}
// First Audio Stream Info
sc_GetBytes(SC_MPEG4_AUDIO_STREAM_INFO_ADDR,
0,
SIZE_OF_AUDIO_STREAM_INFO,
(BYTE*)&_mpeg4AudioStreamInfo
);
if (_mpeg4AudioAvailableNum == 0)
_mpeg4AudioStreamID = NO_STREAM;
determineAudioInfo(&uiAudioSID, &uiAudioSIDDecoder, &dwSamplingRate);
/* Calculate and save playback addresses */
dwStartLBA = dwClipStartAddr + (_dwMP4FirstChunkOffset >> 11);
wClipStartOffset = (WORD)(_dwMP4FirstChunkOffset % LOGICAL_BLOCK_SIZE);
/* Set total clip time */
{
UINT16 uVideoTotalPlaybackTime, uAudioTotalPlaybackTime;
if (_mpeg4VideoStreamID == NO_STREAM)
uVideoTotalPlaybackTime = 0;
else
uVideoTotalPlaybackTime = caclTimeOfFrame( _mpeg4VideoLength, _mpeg4VideoRate, _mpeg4VideoScale);
if (_mpeg4AudioStreamID== NO_STREAM)
uAudioTotalPlaybackTime = 0;
else
// <<< Robin_1012_2004, calculate the total time of CBR/VBR audio
{
if ((_mpeg4AudioScale == AVI_VBR_AUD_STREAM_SCALE) ||(_mpeg4AudioCodec == AAC))
{
// VBR audio
uAudioTotalPlaybackTime = caclTimeOfFrame(_mpeg4AudioLength, _mpeg4AudioRate, _mpeg4AudioScale);
}
else
{
// CBR audio
uAudioTotalPlaybackTime = (_mpeg4AudioLength * _mpeg4AudioScale) / _mpeg4AudioAvgBytesPerSec;
}
}
// >>> Robin_1012_2004,
gns.clips.uTotalPlaybackTime = MAX(uVideoTotalPlaybackTime,uAudioTotalPlaybackTime);
}
dbg_printf(("Total Clip Time: %d secn", gns.clips.uTotalPlaybackTime));
dwMdatSize = _dwMP4LastChunkEndOffset - _dwMP4FirstChunkOffset;
ulBlocksCnt = (wClipStartOffset + dwMdatSize + LOGICAL_BLOCK_SIZE - 1) / LOGICAL_BLOCK_SIZE;
wClipEndOffset = (WORD)((wClipStartOffset + dwMdatSize) % LOGICAL_BLOCK_SIZE);
if (0 == wClipEndOffset)
{
wClipEndOffset = 2048;
}
// _dwMPEG4ClipStartLBA = dwStartLBA;
_dwMPEG4ClipStartLBA = dwClipStartAddr;
_wMPEG4ClipStartOffset = wClipStartOffset;
_wMPEG4ClipEndOffset = wClipEndOffset;
_ulMPEG4TotalBlocksCnt = ulBlocksCnt;
_dwMPEG4FileLocation = dwClipStartAddr;
dwVideoSyncSampleNum = 0UL;
#ifdef PATCH_VIDEO_NOT_B
_bMPEG4IsBVopExist = _mp4DetectBVOP();
#endif
_mp4ChapterInit();
// Robin_1119_2004, restrict the flashcard transfer bytes at one times
{
UINT32 ulAverageChunkSize;
UINT32 ulFlashCardTransferBytes;
ulAverageChunkSize = (_dwMP4LastChunkEndOffset - _dwMP4FirstChunkOffset) / _dwMP4ChunkSizeEntryTotal;
ulFlashCardTransferBytes = ulAverageChunkSize * 32; // DVP store 64 chunk info
ulFlashCardTransferBytes = ((ulFlashCardTransferBytes + 1023) / 1024) * 1024;
tr_printf(("Average Chunk Size : %ld, FlashCard Transfer Bytes: %ld n", ulAverageChunkSize, ulFlashCardTransferBytes));
DEC_MP4_SetFlashCardTransferByte(ulFlashCardTransferBytes);
}
ulEndTime2 = (gen_timer()/1000UL);
tr_printf(("MP4Clip_Play() total time : %ld msecn",ulEndTime2-ulStartTime2));
ie_send(IE_UI_CLIPS_CLEAR_UI);
}
else
{
{
BYTE Temp[4];
AuxCache_GetBytes(dwClipStartAddr, 0, 4, &Temp[0]);
}
/* Resuming, handled as goto time */
DEC_AVI_ChangedSubtitle(_mpeg4SubtitleStreamID);
/* Calculate the video frame to skip to */
_mp4GetAdjacentIFrames(i_pResumeMarker->uTime,&dwVideoSyncSampleNum, &dwSyncSampleOffset);
determineAudioInfo(&uiAudioSID, &uiAudioSIDDecoder, &dwSamplingRate);
if (_ulMPEG4RequestedFrameIndex == 0)
dwSyncSampleOffset = _dwMP4FirstChunkOffset;
dwStartLBA = _dwMPEG4ClipStartLBA + ( dwSyncSampleOffset >> 11);
wClipStartOffset = (WORD)( dwSyncSampleOffset % LOGICAL_BLOCK_SIZE);
ulBlocksCnt = _ulMPEG4TotalBlocksCnt - (dwStartLBA - _dwMPEG4ClipStartLBA);
wClipEndOffset = _wMPEG4ClipEndOffset;
_uiMPEG4StartTime = caclTimeOfFrame(dwVideoSyncSampleNum,_mpeg4VideoRate, _mpeg4VideoScale);
}
// _mp4GetTransferTimes();
// _mp4ClearAPPBuffer();
if (_mpeg4VideoStreamID == NO_STREAM)
Logo_selectSource(eStartup);
_mp4PrePlayProcessing(dwSamplingRate, uiAudioSID, uiAudioSIDDecoder, (i_pThis->m_pConstAttr)->m_eVideoSID,
((NULL != i_pResumeMarker) ? FALSE : TRUE), FALSE);
#if 0 //FW0408_2005D Move to prePlayProcessing()
// Set AVI video scaling
DEC_EnableManualScaling(PROG_SCALER_MODE_CCRAM);
DEC_SetViewMode(gps->view_mode);
#endif
// JG_0819_2004: FF/FB->PLAY/PAUSE need not to do scaling again
//FW_0526_2005B Comment out, move to prePlayProcessing()
//if (NULL == i_pResumeMarker)
//gcst.mNeedScaling = TRUE;
// _mp4ClearAPPBuffer();
API_ADPSetMp3_Throw_Out_Cntr(0);
API_ADP_UpdateTaskParam( UPDATE_TASK_PARAM_MP3_THROW_OUT_CNTR,0 , NOT_SEND_TO_ADP);
DEC_AVI_SetStartVideoChunks(dwVideoSyncSampleNum); // TBD..
DEC_AVI_SetPlaybackParams(wClipStartOffset, wClipEndOffset, _uiMPEG4StartTime, 0, 0);
PE_Clips_SetPlaybackRange(dwStartLBA, ulBlocksCnt, UNLIMITED_FILE_SIZE);
_mp4InitTransferChunkSize(FALSE,0UL);
if (IS_CD_MEDIA)
{
drv_set_bit_rate(DRV_HIGH_BITRATE_E);
}
if (!PE_Clips_Playback_Sectors(DRVCF_CDSPEED_1X | DRVF_PLAY_CD_AV_DATA, dwStartLBA, ulBlocksCnt))
{
dbg_printf(("FATAL: AVIClip_play() Failed [6]n"));
return FALSE;
}
return TRUE;
}
#pragma argsused
void MP4Clip_pause(Clip *i_pThis, BOOL bEnable)
{
dbg_printf(("MP4Clip_pause(%d)n", bEnable));
if (bEnable)
{
/* in case we were in FF, */
if (gns.clips.iScanSpeed != 0)
{
int watchdog = 100;
MP4Clip_scan(i_pThis, 0); /* Resume playback */
//Wait until enter NSPB
while (DEC_getState() != DEC_LL_STATUS0_C_STATE_NSPB && --watchdog)
{
usleep(5000UL);
}
}
/* Clear DVP indication that this is a pause-stop (and not pause) */
DEC_AVI_ClearDemuxSharedBit(AVI_FILE_PAUSE_OFFSET, AVI_FILE_PAUSE_BIT);
API_ADPSetMp3_Throw_Out_Cntr(0);
/* Pause the Decoder */
DEC_PlaybackCommand(DEC_PLAYBACK_CMD_PAUSE, NULL);
}
else
{
#ifdef USE_AUX_SUBTITLES
// RB_TBD
if (FALSE != areAuxSubtitlePresent()) // Robin_0528_2004_A, disable AuxSubtitle function if it not availabe
{
// perform seek in subtitles storage
// replace 0 with the correct time, once it can be determined before playback
// actually resumes
subtitleGoToTime(0);
setSubtitlesPlayMode(TRUE);
}
#endif //USE_AUX_SUBTITLES
/* Resume the Decoder */
/* in case we were in FF, terminate it and resume playback */
DEC_PlaybackCommand(DEC_PLAYBACK_CMD_RESUME, NULL);
}
}
#pragma argsused
void MP4Clip_refresh(Clip *i_pThis)
{
#ifdef MPP_SUPPORT
/* just enable MPP after playback, otherwise screen green or flash */
if( (PST_STOP != gcs.pstate) && (gns.clips.iCurrentTime >= 1) )
{
DEC_SetMPP( gcst.mMPP_Enable );
}
#endif
}
#pragma argsused
enClipStatus MP4Clip_getStatus(const Clip *i_pThis)
{
UINT32 uiNumOfDecodedSampleCurrent;
UINT16 uiVideoDecodingError;
UINT16 uVideoCodeBufferFullness;
MP4VideoSyncEntry mp4VideoSyncEntry;
/* If we are in FF/FB I only, don't regard this status */
#ifdef IP_SUPPORT
if ( (PST_SCAN == gcs.pstate) && (SCAN_SPEED_2X != gns.clips.iScanSpeed) )
#else
if (PST_SCAN == gcs.pstate)
#endif
{
return eCS_Busy;
}
/* In NSPB check the DVP video status and perform error handling if it gets stuck */
DEC_AVI_GetVideoDecodingStatus(&uiNumOfDecodedSampleCurrent,&uiVideoDecodingError);
uVideoCodeBufferFullness = (UINT16)DEC_ReadCodeBufferFullness(DEC_VIDEO_CODE_BUFFER, DEC_FULLNESS_IN_BYTES);
#ifdef SUPPORT_FLASH_CARD
if(IS_PLAYING_CARD)
_uiMPEG4TotalDVPIdleTime += 50; /* Core tick - 200 msec , slow down the counter for card*/
else
#endif
_uiMPEG4TotalDVPIdleTime += 200; /* Core tick - 200 msec */
if ( PST_PLAY == gcs.pstate &&
_uiMPEG4NumOfDecodedChunksMemory == uiNumOfDecodedSampleCurrent &&
(_uiMPEG4TotalDVPIdleTime >= DVP_VIDEO_TASK_WATCHDOG_TIME || uiVideoDecodingError == 0xF) &&
(uVideoCodeBufferFullness != 0))
{
ClipMarker mClipMarker;
UINT16 uiNextIIdx;
WORD wNextITime;
tr_printf(("DVP video error... time: %dn", _uiMPEG4StartTime));
/* Resume playback from the next I frame */
_uiMPEG4NumOfDecodedChunksMemory = 0; /* Prevent re-initiating */
_uiMPEG4TotalDVPIdleTime = 0;
if(TRUE == _mp4GetNextIFrames(uiNumOfDecodedSampleCurrent, &uiNextIIdx, &mp4VideoSyncEntry))
{
if(uiNextIIdx == _uiMPEG4NextIndexEntry)
{
return eCS_Finished;
}
mClipMarker.dwAddress = (i_pThis->m_cfiInfo).dwFileLocation;
wNextITime = (WORD)(caclTimeOfFrame(uiNumOfDecodedSampleCurrent,_mpeg4VideoRate, _mpeg4VideoScale ));
if(wNextITime <= mClipMarker.uTime)
mClipMarker.uTime = wNextITime+1;
else
mClipMarker.uTime = wNextITime;
}
(i_pThis->m_pConstAttr->m_vtable.m_pfPlay)(i_pThis, &mClipMarker, FALSE);
}
else if ( (_uiMPEG4NumOfDecodedChunksMemory != uiNumOfDecodedSampleCurrent) || (0 == _uiMPEG4NumOfDecodedChunksMemory) )
{
_uiMPEG4TotalDVPIdleTime = 0;
}
_uiMPEG4NumOfDecodedChunksMemory = uiNumOfDecodedSampleCurrent;
// transfer chunk size
#ifdef MP4_TANSFER_CHUNKSIZE_BY_FIFO
if ((PST_PLAY == gcs.pstate) || (PST_PAUSE == gcs.pstate) ||(PST_SLOW == gcs.pstate ))
_mp4TransferChunkSizeByFifo();
#else
if ((PST_PLAY == gcs.pstate) || (PST_PAUSE == gcs.pstate) ||(PST_SLOW == gcs.pstate ))
_mp4TransferChunkSize(/*FALSE,*/ FALSE);
#endif
/* Normal speed playback */
if (drv_is_play_done() && DEC_IsPlaybackFinished(FALSE))
{
if (_mpeg4VideoStreamID != NO_STREAM)
return eCS_Finished;
else if ((_uiMPEG4StartTime+1) >= gns.clips.uTotalPlaybackTime)
return eCS_Finished;
}
return eCS_Busy;
}
#pragma argsused
UINT16 MP4Clip_getTime(const Clip *i_pThis)
{
UINT16 uiStatus2 = inport(I64_STATUS_2);
/* Check if the DVP is not running yet */
if ( (uiStatus2 & DVP_UPDATED_SCLK_MASK) == 0 )
{
/* SCLK start time is still not updated by the DVP */
_bMPEG4WasClockEnabled = FALSE;
return _uiMPEG4StartTime;
}
else if (FALSE == _bMPEG4WasClockEnabled)
{
PE_Clips_EnableClock(TRUE, TRUE, _uiMPEG4StartTime);
_bMPEG4WasClockEnabled = TRUE;
}
#ifdef USE_AUX_SUBTITLES
if (FALSE != areAuxSubtitlePresent())// Robin_0528_2004_A
{
// read the SCLK to get better update resolution than 1 sec.
checkAndHandleAuxSubtitles(PE_Clips_GetClock_Raw()); // Robin_2004_0517_B, resolution in ms
}
#endif // USE_AUX_SUBTITLES
if ((PST_PLAY == gcs.pstate) || (PST_PAUSE == gcs.pstate) ||(PST_SLOW == gcs.pstate ))
{
if (_bMP4InternalSubtitle)// Robin_0528_2004_A
{
mp4CheckAndHandleSubtitle(PE_Clips_GetClock_Raw()); // resolution in ms
}
}
_uiMPEG4StartTime = PE_Clips_GetClock();
_mp4ChapterRefresh();
return _uiMPEG4StartTime;
}
#pragma argsused
void MP4Clip_abort(Clip *i_pThis, BOOL bMaintainStandby)
{
#ifdef MPP_SUPPORT
DEC_SetMPP(FALSE);
#endif
DEC_AVI_EnableFinishCB(FALSE);
#ifdef MP4_TANSFER_CHUNKSIZE_BY_FIFO
DEC_MP4_ChunkSizeFifoInit();
#endif
DEC_MP4_SetFlashCardNotNeedCheck();
if (IS_CD_MEDIA)
{
drv_set_bit_rate(DRV_NORMAL_BITRATE_E);
}
GenericClip_abort(i_pThis, bMaintainStandby);
_mp4ClearAPPBuffer();
}
#pragma argsused
void MP4Clip_scan(Clip *i_pThis, int iScanSpeed)
{
INT8 iIndexIncrement;
UINT8 eNoBScanSpeedMap = 0;
if (iScanSpeed > 0)
{
if (iScanSpeed < ((SCAN_SPEED_2X+SCAN_SPEED_4X)/2))
iScanSpeed = SCAN_SPEED_2X;
else if (iScanSpeed <((SCAN_SPEED_4X+SCAN_SPEED_8X)/2))
iScanSpeed = SCAN_SPEED_4X;
else if (iScanSpeed <((SCAN_SPEED_8X+SCAN_SPEED_20X)/2))
iScanSpeed = SCAN_SPEED_8X;
else
iScanSpeed = SCAN_SPEED_20X;
}
else if(iScanSpeed < 0)
{
if (iScanSpeed > -((SCAN_SPEED_2X+SCAN_SPEED_4X)/2))
iScanSpeed = -SCAN_SPEED_2X;
else if (iScanSpeed > -((SCAN_SPEED_4X+SCAN_SPEED_8X)/2))
iScanSpeed = -SCAN_SPEED_4X;
else if (iScanSpeed > -((SCAN_SPEED_8X+SCAN_SPEED_20X)/2))
iScanSpeed = -SCAN_SPEED_8X;
else
iScanSpeed = -SCAN_SPEED_20X;
}
if (iScanSpeed == SCAN_SPEED_2X)
eNoBScanSpeedMap = SCAN_SPEED_4X;
else if (iScanSpeed == SCAN_SPEED_4X)
eNoBScanSpeedMap = SCAN_SPEED_8X;
else if (iScanSpeed == SCAN_SPEED_8X)
eNoBScanSpeedMap = SCAN_SPEED_20X;
else if (iScanSpeed == SCAN_SPEED_20X)
eNoBScanSpeedMap = SCAN_SPEED_40X;
/* Check if we are in scanning */
if (iScanSpeed != 0)
{
if ( (PST_SLOW == gcs.pstate) || (PST_PLAY == gcs.pstate) || (PST_SCAN == gcs.pstate) || (PST_PAUSE == gcs.pstate) )
{
#ifdef USE_AUX_SUBTITLES
if (FALSE != areAuxSubtitlePresent() || _bMP4InternalSubtitle)// Robin_0528_2004_A
{
// stop subtitle seeking
setSubtitlesPlayMode(FALSE);
stopDisplayAuxSubtitles();
}
#endif //USE_AUX_SUBTITLES
#ifdef IP_SUPPORT
if ( ! FOUND_B_PICS_IN_CLIP && iScanSpeed > 0 )
{
iScanSpeed = eNoBScanSpeedMap;
dbg_printf(("No B pictures detectedn"));
}
#else
if ( iScanSpeed > 0 )
{
#ifdef AVI_FF_NO_INDEX
if (TRUE == _bMPEG4TrickModeOn)
#endif
iScanSpeed = eNoBScanSpeedMap;
}
#endif
dbg_printf(("MP4Clip_scan(x%d)n", iScanSpeed));
/* Calculate the increment in the idx table */
switch (iScanSpeed)
{
case SCAN_SPEED_2X:
DEC_AVI_EnableFinishCB(FALSE);
DEC_AVI_SetIOnly(FALSE);
/* If we are moving from I to IP only, need to resume playback */
if (gns.clips.iScanSpeed != 0)
{
MP4Clip_scan(i_pThis, 0); /* Resume playback */
MP4Clip_scan(i_pThis, SCAN_SPEED_2X); /* Resume IP scanning mode */
return;
}
#ifdef AVI_FF_NO_INDEX
if (FALSE == _bMPEG4TrickModeOn)
DEC_AVI_EnableFinishCB(TRUE);
#endif
DEC_AVI_SetIPOnly(TRUE);
iIndexIncrement = I_P_INCREMENT;
_iMPEG4CurrentScanningMode = iIndexIncrement;
gns.clips.iScanSpeed = iScanSpeed;
gcs.pstate= PST_SCAN;
return;
case SCAN_SPEED_4X:
#ifdef AVI_FF_NO_INDEX
if (FALSE == _bMPEG4TrickModeOn)
{
DEC_AVI_SetIPOnly(FALSE);
DEC_AVI_SetIOnly(TRUE);
iIndexIncrement = ONE_I_INCREMENT;
_iMPEG4CurrentScanningMode = iIndexIncrement;
gns.clips.iScanSpeed = iScanSpeed;
gcs.pstate= PST_SCAN;
DEC_AVI_EnableFinishCB(TRUE);
return;
}
else
#endif
iIndexIncrement = ONE_I_INCREMENT;
break;
case SCAN_SPEED_8X:
iIndexIncrement = TOW_I_INCREMENT;
break;
case SCAN_SPEED_20X:
iIndexIncrement = FOUR_I_INCREMENT;
break;
case SCAN_SPEED_40X:
iIndexIncrement = EIGHT_I_INCREMENT;
break;
case (-SCAN_SPEED_2X):
iIndexIncrement = -ONE_I_INCREMENT;
break;
case (-SCAN_SPEED_4X):
iIndexIncrement = -TOW_I_INCREMENT;
break;
case (-SCAN_SPEED_8X):
iIndexIncrement = -FOUR_I_INCREMENT;
break;
case (-SCAN_SPEED_20X):
iIndexIncrement = -EIGHT_I_INCREMENT;
break;
}
/* Check if we changed from IP to I only mode */
if ( (gns.clips.iScanSpeed == SCAN_SPEED_2X) || (gns.clips.iScanSpeed == 0) )
{
gcs.pstate = PST_SCAN;
// first time,
DEC_PlaybackCommand(DEC_PLAYBACK_CMD_STOP, 0);
/* Start I only scan mode */
if (FALSE == _mp4Scan(iIndexIncrement, FALSE))
{
dbg_printf(("WARNNING: AVIClip_scan() FAILEDn"));
}
}
/*
* Else - the DEMUX status polling time was enabled before,
* and so, when the time is triggered the scanning will continue
* according to the updated scanning mode
*/
gns.clips.iScanSpeed = iScanSpeed;
_iMPEG4CurrentScanningMode = iIndexIncrement;
}
}
else
{
/* Playing after scanning - resume playback */
ClipMarker mClipMarker;
#ifdef USE_AUX_SUBTITLES
if (FALSE != areAuxSubtitlePresent())// Robin_0528_2004_A
{
// replace 0 with the correct time, once it can be determined before playback
// actually resumes
subtitleGoToTime(0);
setSubtitlesPlayMode(TRUE);
}
else if (_bMP4InternalSubtitle)
{
setSubtitlesPlayMode(TRUE);
}
#endif //USE_AUX_SUBTITLES
#ifdef AVI_FF_NO_INDEX
if (FALSE == _bMPEG4TrickModeOn)
{
DEC_AVI_SetIPOnly(FALSE);
DEC_AVI_SetIOnly(FALSE);
DEC_AVI_EnableFinishCB(FALSE);
return;
}
else
#endif
{
if (_iMPEG4CurrentScanningMode == I_P_INCREMENT)
{
DEC_AVI_SetIPOnly(FALSE);
}
else /* I only mode */
{
DEC_AVI_SetIOnly(FALSE);
/* Remove DEMUX callback */
DEC_AVI_EnableFinishCB(FALSE);
}
}
/* Save the info used for resuming */
mClipMarker.dwAddress = (i_pThis->m_cfiInfo).dwFileLocation;
mClipMarker.uTime = _uiMPEG4StartTime;
gns.clips.iScanSpeed = 0;
gcs.pstate = PST_PLAY;
/* Resume playback */
(i_pThis->m_pConstAttr->m_vtable.m_pfPlay)(i_pThis, &mClipMarker, FALSE);
}
}
#pragma argsused
void MP4Clip_recordMarker(const Clip *i_pThis, ClipMarker *o_pMarker)
{
dbg_printf(("MP4Clip_recordMarker()n"));
/* Saving the info needed for playback resuming */
o_pMarker->dwAddress = (i_pThis->m_cfiInfo).dwFileLocation;
o_pMarker->uTime = (i_pThis->m_pConstAttr->m_vtable.m_pfGetTime)(i_pThis);
o_pMarker->uClipNumer = gns.clips.uCurrentClipNumber;
}
void MP4Clip_continueScanning(void)
{
/* Verify that we are in FF I only mode */
#ifdef IP_SUPPORT
if ( (gns.clips.iScanSpeed != 0) && (gns.clips.iScanSpeed != SCAN_SPEED_2X) )
#else
if (gns.clips.iScanSpeed != 0)
#endif
{
_mp4Scan(_iMPEG4CurrentScanningMode, TRUE);
}
}
void MP4Clip_performErrorHandling(const Clip *i_pThis)
{
dbg_printf(("MP4Clip_performErrorHandling()n"));
/* The current error handling is only in scanning mode */
/* Check whether we are in FF I only or not */
#ifdef IP_SUPPORT
if ( (gcs.pstate == PST_SCAN) && (gns.clips.iScanSpeed != SCAN_SPEED_2X) )
#else
if (gcs.pstate == PST_SCAN)
#endif
{
/* Remove the callback from the demux */
DEC_AVI_EnableFinishCB(FALSE);
/* Start I only FF from the beginning */
_mp4Scan(_iMPEG4CurrentScanningMode, TRUE);
#ifdef SUPPORT_FLASH_CARD
if(IS_PLAYING_CARD)
_uiMPEG4StartTime += gns.clips.iScanSpeed;
#endif
}
else
{
/* NSPB recovery, resume playback from the next I frame */
ClipMarker mClipMarker;
MP4VideoSyncEntry mp4VideoSyncEntry;
UINT16 uiNextIIdx;
UINT32 uiNumOfDecodedSampleCurrent;
WORD wNextITime;
UINT16 uiVideoDecodingError;
DEC_AVI_GetVideoDecodingStatus(&uiNumOfDecodedSampleCurrent,&uiVideoDecodingError);
if(TRUE == _mp4GetNextIFrames(uiNumOfDecodedSampleCurrent, &uiNextIIdx, &mp4VideoSyncEntry))
{
if(uiNextIIdx == _uiMPEG4NextIndexEntry)
{
return;
}
mClipMarker.dwAddress = (i_pThis->m_cfiInfo).dwFileLocation;
wNextITime = (WORD)(caclTimeOfFrame(uiNumOfDecodedSampleCurrent,_mpeg4VideoRate, _mpeg4VideoScale ));
if(wNextITime <= mClipMarker.uTime)
mClipMarker.uTime = wNextITime+1;
else
mClipMarker.uTime = wNextITime;
}
(i_pThis->m_pConstAttr->m_vtable.m_pfPlay)(i_pThis, &mClipMarker, FALSE);
}
}
static void _mp4SubtitleWriteDRAM(UINT32 ulAddress, UINT16* pBuffer, UINT32 ulLength )
{
UINT32 ulWriteLengthFirst;
UINT32 ulWriteLngthSecond;
UINT32 ulBufferStartAddr, ulBufferEndAddr;
ulBufferStartAddr = _mpeg4InternalSubtitleBufferStartAddr * 512UL;
ulBufferEndAddr = (_mpeg4InternalSubtitleBufferStartAddr + SPB_SIZE_AVI) * 512UL;
while(ulAddress >= ulBufferEndAddr)
{
ulAddress -= (ulBufferEndAddr - ulBufferStartAddr);
}
ulWriteLengthFirst = min(ulLength, ulBufferEndAddr -ulAddress);
ulWriteLngthSecond = ulLength - ulWriteLengthFirst;
wai_sem(SEM_DRAM_ID);
I49_WriteDRAMDataNSW(ulAddress, (UINT16*)pBuffer, ulWriteLengthFirst);
if ( ulWriteLngthSecond != 0UL )
{
I49_WriteDRAMDataNSW(ulBufferStartAddr, (UINT16*)(pBuffer + ulWriteLengthFirst ), ulWriteLngthSecond );
}
sig_sem(SEM_DRAM_ID);
return;
}
static void _mp4SubtitleStoreTimeAndSample(UINT32 ulStartTime,UINT32 ulEndTime,UINT32 ulSampleSize, WORD* pBuffer)
{
UINT32 ulSampleSizeInWord;
ulSampleSizeInWord = (ulSampleSize+1)/2;
_mp4SubtitleWriteDRAM( _dwMP4SubtitleWriteDRAMAddr, (UINT16*)(&ulStartTime), 2);
_mp4SubtitleWriteDRAM( (_dwMP4SubtitleWriteDRAMAddr+2), (UINT16*)(&ulSampleSize), 2);
_mp4SubtitleWriteDRAM( (_dwMP4SubtitleWriteDRAMAddr+4), pBuffer, ulSampleSizeInWord );
_mp4SubtitleWriteDRAM((_dwMP4SubtitleWriteDRAMAddr+4+ulSampleSizeInWord), (UINT16*)(&ulEndTime), 2);
_dwMP4SubtitleWriteDRAMAddr += (6+ulSampleSizeInWord);
}
// Robin_1230_2004, send subpicture pts to DVP
void _mp4SubPictureArrived(void)
{
UINT16 uiStatus;
UINT16 uiTemp1,uiTemp2;
UINT32 uiSPDSize;
UINT16 uiPTS[2];
MP4SubtitleSampleEntry mp4SubtitleSampleEntry;
uiStatus = inport(DS2CFIFO_STATUS_ADDR);
if(!uiStatus)
{
tr_printf(("Nothing in FIFOn"));
return;
}
uiTemp1 = inport(DS2CFIFO_DATA_ADDR);
uiTemp2 = inport(DS2CFIFO_DATA_ADDR);
uiSPDSize = ((DWORD)uiTemp1<<16)|(uiTemp2);
wai_sem(SEM_DRAM_ID);
I49_ReadDRAMData(_dwMP4SubtitleSampleAddr,(UINT16*)&mp4SubtitleSampleEntry, MP4_SUBTITLE_SMAPLE_ENTRY_SIZE);
sig_sem(SEM_DRAM_ID);
_dwMP4SubtitleSampleAddr -= MP4_SUBTITLE_SMAPLE_ENTRY_SIZE;
if (uiSPDSize != mp4SubtitleSampleEntry.dwSampleSize)
tr_printf(("Error: SubPicture size from DVP : %ld, from CPU : %ldn", uiSPDSize, mp4SubtitleSampleEntry.dwSampleSize));
uiPTS[0] = (UINT16)((90UL * mp4SubtitleSampleEntry.dwSampleEndTime) >> 16);
uiPTS[1] = (UINT16)((90UL * mp4SubtitleSampleEntry.dwSampleEndTime) & 0xFFFFUL);
I49_DVPFIFOWrite(&uiPTS, 2);
}
void MP4Clip_subtitleArrived(void)
{
UINT16 uiStatus;
UINT16 uiTemp1,uiTemp2;
UINT32 uiInputBufferSize;
UINT32 uiInputBufferSizeWords;
UINT32 uiInputCount;
BYTE *pSubtitleBuffer;
MP4SubtitleSampleEntry mp4SubtitleSampleEntry;
// static UINT32 ulSubtitleSkipBytes = 0UL;
if (INTERNAL_SUBP == _mpeg4SubtitleType)
{
_mp4SubPictureArrived();
return;
}
uiStatus = inport(DS2CFIFO_STATUS_ADDR);
if(!uiStatus)
{
tr_printf(("Nothing in FIFOn"));
return;
}
uiTemp1 = inport(DS2CFIFO_DATA_ADDR);
uiTemp2 = inport(DS2CFIFO_DATA_ADDR);
uiInputBufferSize = ((DWORD)uiTemp1<<16)|(uiTemp2);
uiInputBufferSizeWords = (uiInputBufferSize+1)/2;
pSubtitleBuffer = (BYTE*)malloc(uiInputBufferSizeWords * sizeof(WORD) );
if (NULL == pSubtitleBuffer)
{
tr_printf(("FATAL: couldn't allocate memory for subtitle buffer, size: %ldn", (uiInputBufferSizeWords*2)));
// RB_TBD
return;
}
for(uiInputCount=0; uiInputCount<uiInputBufferSizeWords; uiInputCount++)
{
int timeOut = 0;
do {
uiStatus = inport(DS2CFIFO_STATUS_ADDR);
if (timeOut > 10000)
{
dbg_printf(("WARNING: MP4Clip_subtitleArrived() Failed!n"));
// RB_TBD
free(pSubtitleBuffer);
return;
}
timeOut++;
} while ( uiStatus < 1 );
uiTemp1 = inport(DS2CFIFO_DATA_ADDR);
pSubtitleBuffer[2*uiInputCount] = (BYTE)(uiTemp1 >> 8);
pSubtitleBuffer[(2*uiInputCount)+1] = (BYTE)(uiTemp1 & 0xFF);
}
uiInputCount = 0;
while(uiInputCount < uiInputBufferSize)
{
UINT32 ulStartTime;
UINT32 ulEndTime;
UINT32 ulSampleSize;
wai_sem(SEM_DRAM_ID);
I49_ReadDRAMData(_dwMP4SubtitleSampleAddr,(UINT16*)&mp4SubtitleSampleEntry, MP4_SUBTITLE_SMAPLE_ENTRY_SIZE);
sig_sem(SEM_DRAM_ID);
_dwMP4SubtitleSampleAddr -= MP4_SUBTITLE_SMAPLE_ENTRY_SIZE;
ulStartTime = _dwMP4SubtitleSampleStartTime;
_dwMP4SubtitleSampleStartTime = mp4SubtitleSampleEntry.dwSampleEndTime;
ulEndTime = _dwMP4SubtitleSampleStartTime;
ulSampleSize = mp4SubtitleSampleEntry.dwSampleSize;
// uiInputCount += mp4SubtitleSampleEntry.dwSampleSize;
if ((mp4SubtitleSampleEntry.dwSampleSize == 1) && (pSubtitleBuffer[uiInputCount] == 0))
{
uiInputCount += mp4SubtitleSampleEntry.dwSampleSize;
continue;
}
_mp4SubtitleStoreTimeAndSample(ulStartTime,ulEndTime,ulSampleSize,(WORD*)(pSubtitleBuffer+uiInputCount));
uiInputCount += mp4SubtitleSampleEntry.dwSampleSize;
}
free(pSubtitleBuffer);
}
#endif