开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 多媒体 > DVD > 查看源码
AuxSubtitles.c
资源名称：tb_i86_wr_1019_1102.　[点击查看]
上传用户：super_houu
上传日期：2008-09-21
资源大小：4099k
文件大小：56k
源码类别：

DVD

开发平台：

Others

AuxSubtitles.c：源码内容
  1. /**************************************************************
  2.  *  AuxSubtitles.c
  3.  **************************************************************
  4.  *  Description:
  5.  *  ============
  6.  *  Handling of auxiliary subtitles files
  7.  **************************************************************
  8.  *
  9.  *  Hagay Barel 10.11.03
  10.  **************************************************************/
  12. #include "Config.h" // Global Configuration - do not remove!
  14. #ifdef USE_AUX_SUBTITLES
  17. #ifdef _DEBUG
  18. #undef IFTRACE
  19. #ifdef DEBUG_AUX_SUBTITLES
  20. #define IFTRACE if (gTraceNavigator)
  21. #else
  22. #define IFTRACE
  23. #endif // DEBUG_AUX_SUBTITLES
  24. #include "Debugdbgmain.h"
  25. #endif // _DEBUG
  27. #include "PlaycoreNav_ClipsClip_Impl.h"
  28. #include "PlaycoreNav_ClipsGenericClip.h"
  29. #include "PlaycoreFileSysFileSystem.h"
  30. #include "PlaycoreExceptionException.h"
  31. #include "Decoderlow_levelDEC_LL_Reg.h"
  32. #include "KernelKer_API.H"
  33. #include "KernelEventDef.h"
  34. #include "PlaycoreScPadScPadAlloc.h"
  35. #include "PlaycoreScPadSCMGR.h"
  36. // <<< Robin_0903_2004
  37. //#include "PlaycoreNav_ClipsAVI_private.h"
  38. //#include "PlaycoreNav_ClipsAVI.h"
  39. #include "PlaycoreCoremainCoreGDef.h"
  40. // >>> Robin_0903_2004
  41. #ifdef DEBUG_AUX_SUBTITLES
  42. #include "CpuTimefunc.h"
  43. #endif
  45. #include "PlaycoreNav_ClipsAuxSubtitles.h"
  46. #include "PlaycoreNav_ClipsAuxSubtitlesCommonPrivate.h"
  47. #include "PlaycoreNav_ClipsMpeg4ClipsCommon.h"
  49. #ifdef SUPPORT_FLASH_CARD
  50. #include "drivefe_manager.h"
  51. #include "mediacardsincluderegister.h"
  52. #endif
  54. SubtitleStorageInterface* g_pSubtitleStorage = NULL;
  55. static BOOL _allocateStorageInterface(void);
  56. #ifdef AUX_SUBTITLES_INDEX
  57. SubtitleStorageIndex* g_pSubtitleIndex = NULL;
  58. static BOOL _allocateStorageIndex(void);
  59. #endif // AUX_SUBTITLES_INDEX
  60. #ifdef V882_FLASH_CARD
  61. BOOL _freeStorageInterfaceAndIndex(void);
  62. #else
  63. static BOOL _freeStorageInterfaceAndIndex(void);
  64. #endif//V882_FLASH_CARD
  65. static DWORD g_dwNextSubtitleUpdateSCLK = 0xffffffffL;
  66. static BYTE g_wSubtitleStatus = 0;
  68. DWORD g_dwSubtitleExtraOffset;
  70. #ifdef SUPPORT_FLASH_CARD
  71. BOOL bReadAuxSubtitle;
  72. #endif
  74. UINT16 getCurrentInstanceIndex(void);
  76. // Set when the reading pointer for subtitle storage points at the beginning of
  77. // a subtitle, cleared when it points to the end.
  78. #define AUX_SUBTITLE_START_DISPLAY_FLAG 1
  79. // Set when the string buffer was filled by the core task, but not yet handled
  80. // by the UI task
  81. #define AUX_SUBTITLE_BUFFER_LOCKED_FLAG 2
  82. // Set on normal playback - sequential subtitle seeking is performed.
  83. // Cleared on beginning of FF/FB/Goto
  84. #define AUX_SUBTITLE_PLAY_MODE_FLAG     4
  85. // Set when subtitles exist. When set, the UI will respond to the "Subtitle" key.
  86. #define AUX_SUBTITLE_AVAILABE_FLAG      8
  88. #define IS_AUX_SUBTITLE_START_DISPLAY  (g_wSubtitleStatus & AUX_SUBTITLE_START_DISPLAY_FLAG)
  89. #define IS_AUX_SUBTITLE_BUFFER_LOCKED  (g_wSubtitleStatus & AUX_SUBTITLE_BUFFER_LOCKED_FLAG)
  90. #define IS_AUX_SUBTITLE_PLAY_MODE     (g_wSubtitleStatus & AUX_SUBTITLE_PLAY_MODE_FLAG)
  91. // <<< Robin_0903_2004
  92. #ifdef DIVX_SUPPORT_MULTI_SUBTITLE
  93. #define IS_AUX_SUBTITLE_EXIST     (g_wSubtitleStatus & AUX_SUBTITLE_AVAILABE_FLAG)
  94. #define IS_AUX_SUBTITLE_AVAILABE     ((g_wSubtitleStatus & AUX_SUBTITLE_AVAILABE_FLAG) && (_mpeg4SubtitleType> INTERNAL_SUBT))
  95. #else
  96. // <<< Robin_0907_2004
  97. #define IS_AUX_SUBTITLE_EXIST     (g_wSubtitleStatus & AUX_SUBTITLE_AVAILABE_FLAG)
  98. // >>> Robin_0907_2004
  99. #define IS_AUX_SUBTITLE_AVAILABE     (g_wSubtitleStatus & AUX_SUBTITLE_AVAILABE_FLAG)
  100. #endif
  101. // >>> Robin_0903_2004
  102. #define SET_AUX_SUBTITLE_START_DISPLAY(b) (g_wSubtitleStatus = (b) ? g_wSubtitleStatus | AUX_SUBTITLE_START_DISPLAY_FLAG : g_wSubtitleStatus & ~AUX_SUBTITLE_START_DISPLAY_FLAG )
  103. #define SET_AUX_SUBTITLE_BUFFER_LOCKED(b) (g_wSubtitleStatus = (b) ? g_wSubtitleStatus | AUX_SUBTITLE_BUFFER_LOCKED_FLAG : g_wSubtitleStatus & ~AUX_SUBTITLE_BUFFER_LOCKED_FLAG )
  104. #define SET_AUX_SUBTITLE_PLAY_MODE(b)     (g_wSubtitleStatus = (b) ? g_wSubtitleStatus | AUX_SUBTITLE_PLAY_MODE_FLAG     : g_wSubtitleStatus & ~AUX_SUBTITLE_PLAY_MODE_FLAG )
  105. #define SET_AUX_SUBTITLE_AVAILABE(b)      (g_wSubtitleStatus = (b) ? g_wSubtitleStatus | AUX_SUBTITLE_AVAILABE_FLAG      : g_wSubtitleStatus & ~AUX_SUBTITLE_AVAILABE_FLAG )
  106. // Robin_0527_2004_A
  108. #define CALC_SUBTITLE_ADDRESS(address, offset) (address - (offset >> 1) - STORAGE_INTERFACE_BUFFER_SIZE/2)
  109. // Robin_1003_2004_E
  110. /* Valid Extenions List */
  111. BEGIN_CLIP_VALID_EXTENSIONS_MAP(SUB)
  112. CLIP_VALID_EXTENSIONS_ENTRY(L"SUB")
  113. CLIP_VALID_EXTENSIONS_ENTRY(L"SRT")
  114. CLIP_VALID_EXTENSIONS_ENTRY(L"TXT")
  115. #ifdef SUPPORT_SAMI_SUBTITLE
  116. CLIP_VALID_EXTENSIONS_ENTRY(L"SMI")
  117. #endif
  118. CLIP_VALID_EXTENSIONS_ENTRY(L"SSA")
  119. CLIP_VALID_EXTENSIONS_ENTRY(L"ASS")
  120. CLIP_VALID_EXTENSIONS_ENTRY(L"PSB")
  121. #ifdef SUPPORT_SAMI_SUBTITLE
  122. CLIP_VALID_EXTENSIONS_ENTRY(L"SAMI")
  123. #endif
  124. END_CLIP_VALID_EXTENSIONS_MAP()
  126. /////////////////////////////////////////////////////////////////////////////////////////////
  127. // Function name : initAuxSubtitles
  128. // Purpose : Initializes auxiliary subtitles for a clip
  129. // Input Parameters : clipInfo   - Information about the clip for which
  130. // to initialize subtitles
  131. //   dwScale, dwRate - dwScale/dwRate is the number of seconds
  132. // per video frame
  133. // Return type : TRUE if subtitles were loaded, FALSE otherwise.
  134. // Description : The function looks for a subtitle files belonging to the given clip,
  135. //   performs parsing and initializes interrupt and event handlers.
  136. /////////////////////////////////////////////////////////////////////////////////////////////
  137. BOOL initAuxSubtitles(ClipFileInfo *clipInfo, DWORD dwScale, DWORD dwRate)
  138. {
  139. DWORD dwSubtitlesFileAddress;
  140. DWORD dwSubtitlesFileSize;
  141. SubtitleParsingFuncPtr pfParseSubtitles;
  142. WORD wSubtitleID; // Robin_0903_2004
  143.    /* SubtitlesFormatID sfFormatID; */
  145. #ifdef DEBUG_AUX_SUBTITLES
  146. UINT32 dwStart, dwEnd;
  147. #endif
  149. g_dwSubtitleExtraOffset = 0;
  151. // <<< Stivenz_1115_04: Memory optimization: Move g_SubtitleStorage and g_SubtitleIndex to heap.
  152. if(!_allocateStorageInterface())
  153. return FALSE;
  154. #ifdef AUX_SUBTITLES_INDEX
  155. if(!_allocateStorageIndex())
  156. {
  157. _freeStorageInterfaceAndIndex();
  158. return FALSE;
  159. }
  160. #endif
  161. // Stivenz_1115_04 >>>
  162.    // this flag determines whether the UI will respond to the "subtitle" key
  163.    // if subtitles exist, it would be set to true.
  164.    SET_AUX_SUBTITLE_AVAILABE(FALSE);
  166.    g_dwNextSubtitleUpdateSCLK = LAST_SUBTITLE_MARKER;
  168. #ifdef SUPPORT_FLASH_CARD
  169. if (IS_PLAYING_CARD)
  170. bReadAuxSubtitle = TRUE;
  171. #endif
  173. #ifdef DEBUG_AUX_SUBTITLES
  174.    dwStart=gen_timer();
  175. #endif
  176. // is there an associated subtitle file of a recognized format?
  177. // <<< Robin_0903_2004
  178. #ifdef DIVX_SUPPORT_MULTI_SUBTITLE
  179. if (clipInfo->wSubFileCnt == 1)
  180. {
  181. wSubtitleID = 0;
  182. }
  183. else
  184. {
  185. wSubtitleID = Get_SubFile_Select();
  186. }
  187. if ( FALSE == findAndCheckAuxSubtitlesFile(clipInfo,&dwSubtitlesFileAddress,&dwSubtitlesFileSize,&pfParseSubtitles, wSubtitleID))
  188. #else
  189. if ( FALSE == findAndCheckAuxSubtitlesFile(clipInfo,&dwSubtitlesFileAddress,&dwSubtitlesFileSize,&pfParseSubtitles/*, &sfFormatID */))
  190. #endif
  191.  {
  192. // >>> Robin_0903_2004
  193. dbg_printf(("initAuxSubtitles - Auxiliary subtitles file wasn't foundn"));
  195. #ifdef SUPPORT_FLASH_CARD
  196. if (IS_PLAYING_CARD)
  197. bReadAuxSubtitle = FALSE;
  198. #endif
  199. return FALSE;
  200. }
  202. // _mpeg4ExternalSubtitleAddr = _dwMPEG4ProcessingEndAddr;
  204. #ifdef DEBUG_AUX_SUBTITLES
  205.    dwEnd=gen_timer();
  206.    dbg_printf(("Subtitles finding & probing time: %lun",dwEnd-dwStart));
  207. #endif
  208.    // if so, parse it and store its content.
  209. if ( FALSE == pfParseSubtitles(dwSubtitlesFileAddress,dwSubtitlesFileSize,dwScale,dwRate)) {
  210. tr_printf(("initAuxSubtitles - Couldn't parse subtitles filen"));
  211. #ifdef DEBUG_AUX_SUBTITLES
  212.     dwEnd=gen_timer();
  213.     dbg_printf(("Total subtitles handling time: %lun",dwEnd-dwStart));
  214. #endif
  216. #ifdef SUPPORT_FLASH_CARD
  217. if (IS_PLAYING_CARD)
  218. bReadAuxSubtitle = FALSE;
  219. #endif
  220. return FALSE;
  221. }
  222. // Robin_0527_2004_A
  223. _dwMPEG4ProcessingEndAddr = (CALC_SUBTITLE_ADDRESS( _mpeg4ExternalSubtitleAddr, g_pSubtitleStorage->dwCurrentStorageOffset) >>9) <<9;
  224. _dwMPEG4ProcessingEndAddr = (_dwMPEG4ProcessingEndAddr>>9)<<9;
  225.  
  226. dbg_printf(("Start Address of Current External Subtitle : 0x%lxn",_dwMPEG4ProcessingEndAddr));
  228. subtitleStorageInitReading();
  229.    subtitleStorageGetStartTime(&g_dwNextSubtitleUpdateSCLK);
  230.    SET_AUX_SUBTITLE_START_DISPLAY(TRUE);
  231.    SET_AUX_SUBTITLE_BUFFER_LOCKED(FALSE);
  232.    SET_AUX_SUBTITLE_AVAILABE(TRUE);
  233.    setSubtitlesPlayMode(TRUE);
  234. //   g_dwSubtitleTimingOffset = 0;
  236. #ifdef DEBUG_AUX_SUBTITLES
  237.    dwEnd=gen_timer();
  238.    dbg_printf(("Total subtitles handling time: %lun",dwEnd-dwStart));
  239. #endif
  240.    // initialize interrupt handlers?
  242. #ifdef SUPPORT_FLASH_CARD
  243. if (IS_PLAYING_CARD)
  244. bReadAuxSubtitle = FALSE;
  245. #endif
  247. return TRUE;
  248. }
  251. /////////////////////////////////////////////////////////////////////////////////////////////
  252. // Function name : findAndCheckAuxSubtitlesFile
  253. // Purpose : looks for a subtitle file for the given clip
  254. // Input Parameters : clipInfo  - Information about the clip for which
  255. //    to look for subtitles
  256. // Output Parameters: dwSubtitlesFileAddress - Start address of the 1st subtitles file that was found
  257. //   dwSubtitlesFileSize  - Size of the subtitles 1st file that was found
  258. //   pfParse  - The parsing function used by the detected format
  259. //    of the 1st recognized subtitle file.
  260. //    prParse=NULL if none was found.
  261. // Return type : TRUE if recognized subtitles were found, FALSE otherwise.
  262. // Description : The function looks for files which have the same name (only name, not extension)
  263. //   as the given clip, and tests if they are recognized subtitle files.
  264. //   It then determines the format of the 1st such file.
  265. /////////////////////////////////////////////////////////////////////////////////////////////
  266. // <<< Robin_0903_2004
  267. #ifdef DIVX_SUPPORT_MULTI_SUBTITLE
  268. BOOL findAndCheckAuxSubtitlesFile(ClipFileInfo *clipInfo,DWORD *dwSubtitlesFileAddress,
  269.   DWORD *dwSubtitlesFileSize,SubtitleParsingFuncPtr *pfParse, WORD wSubtitleID)
  270. #else
  271. BOOL findAndCheckAuxSubtitlesFile(ClipFileInfo *clipInfo,DWORD *dwSubtitlesFileAddress,
  272.   DWORD *dwSubtitlesFileSize,SubtitleParsingFuncPtr *pfParse)
  273. #endif
  274. // >>> Robin_0903_2004
  275. {
  277. // Robin_0527_2004_A, change the process of checking a subtitle file, change the memory allocate of subtitle
  278. // subtitle file name: avi_file_name + .SRT/.SUB/.SMI/..
  279. // limition:
  280. // 1) only support .SRT(SubRip)/.SUB(MicroDVD)/.TXT(MicroDVD)/.SMI(SAMI)/.SUB(SubViewer2.0)
  281. //   .SSA(SubStation Alpha)/.ASS(Advanced SubStation Alpha)/.PSB(PowerDivX)/.TXT(TMPlayer)
  282. // 2) only support one external subtitle and no exist of internal subtitle
  283. // 3) only support western/central european language
  284. // 4) if USE_AUX_SUBTITLES, the cpu code size will exceed 1M(need SUPPORT_2M_FLASH)
  285. // 5) the max size of subtitle in memory is 200KB (SUBTITLES_MEMORY_SIZE)
  286. // 6) the max size of avi file name is  65
  287. // Robin_0715_2004, merge changelist #24166
  288. #if 1
  289. // <<< Robin_0903_2004
  290. #ifdef DIVX_SUPPORT_MULTI_SUBTITLE
  291. if(clipInfo->wSubFileCnt == 0 ||clipInfo->wSubFileCnt <= wSubtitleID )
  292. return FALSE;
  293. else
  294. {
  295. int i,j;
  296. Extend_Subtitle_Info_St SubtitleInfo;
  297. BOOL bAuxSubtitle = FALSE;
  298. SubtitleType auxSubtitleType;
  299. sc_GetBytes( SC_AVI_EXTEND_SUBTITLE_ADDR,
  300.        ( ((clipInfo->wSubFileIndex)+wSubtitleID) * sizeof(Extend_Subtitle_Info_St) ),
  301.        sizeof(Extend_Subtitle_Info_St),
  302.        (BYTE*)&SubtitleInfo );
  304. *dwSubtitlesFileAddress = SubtitleInfo.dwSubtitlesFileAddress;
  305. // <<< Robin_1003_2004_E
  306. *dwSubtitlesFileSize = SubtitleInfo.dwSubtitlesFileSize;
  308. #ifdef SUPPORT_FLASH_CARD //JERRYC_2004_Oct_21
  309. if(IS_PLAYING_CARD)
  310. {
  311. STRUCT_FILE *pfile = FCU_TEMP_SUBTITLE_FILE_STRCUT_ADDR;
  312.       //Is *dwSubtitlesFileAddress the real subtitle file start address?
  313. FileSys_FileOpen(pfile, *dwSubtitlesFileAddress, 0, *dwSubtitlesFileSize);
  314. }
  315. #endif
  318. for (j=0;j<SF_NUMBER_OF_FORMATS;j++)
  319. {
  320. if ( NULL != availableSubtitleFormats[j].pfProbe)
  321. {
  322. if (TRUE == availableSubtitleFormats[j].pfProbe(*dwSubtitlesFileAddress, *dwSubtitlesFileSize))
  323. {
  324. *pfParse=availableSubtitleFormats[j].pfParse;
  325. bAuxSubtitle = TRUE;
  326. auxSubtitleType = j+EXTERNAL_SUBP;
  327. break;
  328. }
  329. }
  330. }
  331. // >>> Robin_1003_2004_E
  333. if (bAuxSubtitle == TRUE)
  334. {
  335. // <<< Robin_0907_2004
  336. if (auxSubtitleType != SAMI && auxSubtitleType != EXTERNAL_SUBP)
  337. {
  338. // Robin_1119_2004, unknown auxsubtitle language
  339. memset(&_mpeg4SubtitleStreamInfo, 0, sizeof(MPEG4SubtitleStreamInfo));
  340. _mpeg4SubtitleStreamID = NO_STREAM;
  341. _mpeg4SubtitleType = auxSubtitleType;
  343. sc_SetBytes(SC_MPEG4_SUBTITLE_STREAM_INFO_ADDR,
  344. (SI_CLIPS_SUB_AVAILABLE_NUM * SIZE_OF_SUBTITLE_STREAM_INFO),
  345. SIZE_OF_SUBTITLE_STREAM_INFO,
  346. (BYTE*)&_mpeg4SubtitleStreamInfo
  347.      );
  348.       
  349. SI_CLIPS_SUB_AVAILABLE_NUM ++;
  350. }
  351.       }
  352. // >>> Robin_0907_2004
  353. return bAuxSubtitle;
  354. }
  355. #else
  356. int i,j;
  357. // <<< Robin_1003_2004_E
  358. if ((NULL != clipInfo->dwSubtitlesFileAddress) && (NULL != clipInfo->dwSubtitlesFileSize))
  359. {
  360. *dwSubtitlesFileAddress = clipInfo->dwSubtitlesFileAddress;
  361. *dwSubtitlesFileSize = clipInfo->dwSubtitlesFileSize;
  363. for (j=0;j<SF_NUMBER_OF_FORMATS;j++)
  364. {
  365. if ( NULL != availableSubtitleFormats[j].pfProbe)
  366. {
  367. if (TRUE == availableSubtitleFormats[j].pfProbe(*dwSubtitlesFileAddress, *dwSubtitlesFileSize))
  368. {
  369. *pfParse=availableSubtitleFormats[j].pfParse;
  370. return TRUE;
  371. }
  372. }
  373. }
  374. }
  375. // >>> Robin_1003_2004_E
  376. return FALSE;
  377. #endif
  378. // >>> Robin_0903_2004
  379. #else
  380. #define AUXSUBTITLE_MAX_FILENAME_LEN 65 // same as szFileID[65]
  381. WCHAR szFilename [AUXSUBTITLE_MAX_FILENAME_LEN];
  382.     LPCWSTR *i_aValidExtensions;
  383. unsigned int FsType;
  384.     int i,j;
  385.     BOOL bFindAuxSubtitlesFile = FALSE;
  386. int FileNameLength;
  388. FsType = FileSys_determineType();
  389. if (FileSys_selectType(FsType) && FileSys_initialize(TRUE))
  390. {
  392. if (FALSE == FileSys_changeDir(clipInfo->szDirectoryName))
  393. {
  394. return FALSE;
  395. }
  397. memset(&szFilename, 0, AUXSUBTITLE_MAX_FILENAME_LEN<<1);
  398. wcsncpy(szFilename,clipInfo->szFilename,wcslen(clipInfo->szFilename));
  400. if (CLIPS_MAX_FILENAME_LEN <= wcslen(clipInfo->szFilename))
  402. {
  403. if (FileSys_fileExists(szFilename)) 
  404. {
  405. FindData fdInfo;
  406. UINT16 hFileFind= FileSys_findFirstFile(szFilename, &fdInfo);
  408. if (NULL == hFileFind) 
  409. return FALSE;
  411. do {
  412. if (fdInfo.dwStartAddr == clipInfo->dwFileLocation)
  413. {
  414. LPWSTR pszDelim;
  415. memset(&szFilename, 0, AUXSUBTITLE_MAX_FILENAME_LEN<<1);
  417. pszDelim= wcsrchr(fdInfo.szFileID, '.');
  418. wcsncpy(szFilename, fdInfo.szFileID, (int)(pszDelim - fdInfo.szFileID));
  419. break;
  420. }
  421. } while (FileSys_findNextFile(hFileFind, &fdInfo));
  423. FileSys_findClose(hFileFind);
  424. }
  426.             
  427. }
  429. FileNameLength = wcslen(szFilename);
  431. for (i=0; i< SF_NUMBER_OF_FORMATS; i++)
  432. {
  434. i_aValidExtensions = availableSubtitleFormats[i].aFormatValidExtensions;
  436. for (j=0;NULL != i_aValidExtensions[j];j++)
  437. {
  438. wcsncat(szFilename, i_aValidExtensions[j],wcslen(i_aValidExtensions[j]));
  439. if (FileSys_fileExists(szFilename)) 
  440. {
  441. FindData fdInfo;
  442. UINT16 hFileFind= FileSys_findFirstFile(szFilename, &fdInfo);
  444. if (NULL != hFileFind) 
  445. {
  446. dbg_printf(("The subtitle file is found.n"));
  447. *dwSubtitlesFileAddress= fdInfo.dwStartAddr;
  448. *dwSubtitlesFileSize= (DWORD)fdInfo.cbFileSizeLow;
  449. if ( NULL != availableSubtitleFormats[i].pfProbe)
  450. {
  451. if (TRUE == availableSubtitleFormats[i].pfProbe(*dwSubtitlesFileAddress, *dwSubtitlesFileSize))
  452. *pfParse=availableSubtitleFormats[i].pfParse;
  453. else
  454. continue;
  455. }
  456. *pfParse=availableSubtitleFormats[i].pfParse;
  457. FileSys_findClose(hFileFind);
  458. return TRUE;
  459. }
  460. }
  462. memset(&szFilename[FileNameLength], 0, wcslen(i_aValidExtensions[j])<<1);
  464. }
  466. }
  468. }     
  470. return FALSE;
  471. #endif
  472. }
  475. void findAuxSubtitlesFile(Clip *pClip, const FindData *i_pFileInfo)
  476. {
  477. if ((eClipType_AVI == (pClip->m_pConstAttr)->m_eType)
  478. #ifdef IS_ASF_CAPABLE
  479. || (eClipType_ASF == (pClip->m_pConstAttr)->m_eType)
  480. #endif
  481. #ifdef IS_MP4_CAPABLE
  482. || (eClipType_MP4 == (pClip->m_pConstAttr)->m_eType)
  483. #endif
  484. )
  485. {
  486. int i,j;
  487. LPCWSTR *i_aValidExtensions;
  488. LPWSTR pszDelim;
  489. WCHAR szFilename [65];
  490. int FileNameLength;
  492. pszDelim= wcsrchr(i_pFileInfo->szFileID, '.');
  493. memset(&szFilename, 0, 65<<1);
  494. wcsncpy(szFilename, i_pFileInfo->szFileID, (int)(pszDelim - i_pFileInfo->szFileID+1));
  496. FileNameLength = wcslen(szFilename);
  497. // Robin_1112_2004, "*" mean any char/string
  498. #if 1 //MikeX_1213_2004_A
  499. wcsncat(szFilename, FILESYS_WILDCARD_SEARCH, sizeof(WCHAR));
  500. #endif
  502. // <<< Robin_0903_2004
  503. #ifdef DIVX_SUPPORT_MULTI_SUBTITLE
  504. (pClip->m_cfiInfo).wSubFileIndex = _mpeg4TotalSubtitleNum;
  505. (pClip->m_cfiInfo).wSubFileCnt = 0;
  506. #else
  507. (pClip->m_cfiInfo).dwSubtitlesFileAddress = NULL;
  508. // Robin_1003_2004_E
  509. (pClip->m_cfiInfo).dwSubtitlesFileSize = NULL;
  510. #endif
  512. // Robin_0730_2004, improve the speed of findAuxSubtitlesFile()
  513. {
  514. FindData fdInfo;
  515. UINT16 hFileFind= FileSys_findFirstFile(szFilename, &fdInfo);
  517. if (NULL == hFileFind) 
  518. {
  519. #ifdef DIVX_SUPPORT_MULTI_SUBTITLE
  520. (pClip->m_cfiInfo).wSubFileIndex = 0;
  521. #endif
  522. return;
  523. }
  525. do {
  526. // Robin_1125_2004, if subtitle filesize larger than 1MB, not supported
  527. if (fdInfo.cbFileSizeLow > 1000000UL) // if filesize is larger than 1MB, not text subtitle
  528. continue;
  530. #ifdef SUPPORT_FLASH_CARD
  531. if(IS_PLAYING_CARD){
  532.                if(0 != wcsncmp(fdInfo.szFileID, i_pFileInfo->szFileID, FileNameLength))
  533.                 continue;
  534. }
  535. #endif
  537. // <<< Robin_1003_2004_E
  538. if (GenericClip_isKindOf(fdInfo.szFileID, CLIP_VALID_EXTENSIONS(SUB)))
  539. {
  540. #ifdef DIVX_SUPPORT_MULTI_SUBTITLE
  541. Extend_Subtitle_Info_St foundSubtitle;
  544. foundSubtitle.dwSubtitlesFileAddress = fdInfo.dwStartAddr;
  545. foundSubtitle.dwSubtitlesFileSize = fdInfo.cbFileSizeLow;
  546. sc_SetBytes( SC_AVI_EXTEND_SUBTITLE_ADDR,
  547.        (_mpeg4TotalSubtitleNum * sizeof(Extend_Subtitle_Info_St) ),
  548.        sizeof(Extend_Subtitle_Info_St),
  549.        (BYTE*)&foundSubtitle );
  550. (pClip->m_cfiInfo).wSubFileCnt ++;
  551. _mpeg4TotalSubtitleNum++;
  552. #else
  554. FileSys_findClose(hFileFind);
  555. (pClip->m_cfiInfo).dwSubtitlesFileAddress = fdInfo.dwStartAddr;
  556. (pClip->m_cfiInfo).dwSubtitlesFileSize = fdInfo.cbFileSizeLow;
  557. break;
  558. #endif
  559. // <<< Robin_0903_2004
  560. }
  561. // >>> Robin_1003_2004_E
  562. } while (FileSys_findNextFile(hFileFind, &fdInfo));
  564. FileSys_findClose(hFileFind);
  566. #ifdef SUPPORT_FLASH_CARD
  567. if(IS_PLAYING_CARD){
  568. FileSys_findFirstFile(i_pFileInfo->szFileID, &fdInfo);
  569.          }
  570. #endif
  572. }
  573. }
  575. return;
  576. }
  578. /////////////////////////////////////////////////////////////////////////////////////////////
  579. // Function Name : subtitleStorageInitWriting
  580. // Purpose : Initializes the interface to the subtitles storage
  581. // Return type : void
  582. // Description :
  583. /////////////////////////////////////////////////////////////////////////////////////////////
  584. void subtitleStorageInitWriting(void)
  585. {
  586. // <<< Stivenz_1115_04: Memory optimization: Move g_SubtitleStorage and g_SubtitleIndex to heap.
  587. if(!_allocateStorageInterface())
  588. return;
  589. // Stivenz_1115_04 >>>
  590. memset(g_pSubtitleStorage,0,sizeof(SubtitleStorageInterface));
  591. #ifdef AUX_SUBTITLES_INDEX
  592. // <<< Stivenz_1115_04: Memory optimization: Move g_SubtitleStorage and g_SubtitleIndex to heap.
  593. if(!_allocateStorageIndex())
  594. return;
  595. // Stivenz_1115_04 >>>
  596.    memset(g_pSubtitleIndex,0,sizeof(SubtitleStorageIndex));
  597.    g_pSubtitleIndex->wInterval = 1;
  598. #endif // AUX_SUBTITLES_INDEX
  599. }
  601. /////////////////////////////////////////////////////////////////////////////////////////////
  602. // Function Name : subtitleStorageInitReading
  603. // Purpose : Initializes the interface to the subtitles storage
  604. // Return type : void
  605. // Description :
  606. /////////////////////////////////////////////////////////////////////////////////////////////
  607. void subtitleStorageInitReading(void)
  608. {
  609. // <<< Stivenz_1115_04: Memory optimization: Move g_SubtitleStorage and g_SubtitleIndex to heap.
  610. if(!_allocateStorageInterface())
  611. return;
  612. // Stivenz_1115_04 >>>
  613. memset(g_pSubtitleStorage,0,sizeof(SubtitleStorageInterface));
  614.    subtitleStorageFillBuffer();
  615. }
  617. /////////////////////////////////////////////////////////////////////////////////////////////
  618. // Function Name : subtitleStorageMarkLastEntry
  619. // Purpose : to be used after the last subtitle was parsed.
  620. // Return type : TRUE - on success. FALSE when out of subtitle storage memory
  621. // Description : writes LAST_SUBTITLE_MARKER to the next position in the subtitle
  622. //    storage.
  623. /////////////////////////////////////////////////////////////////////////////////////////////
  624. BOOL subtitleStorageMarkLastEntry(void)
  625. {
  626. if (!subtitleStorageWriteDWORD(LAST_SUBTITLE_MARKER))
  627. return FALSE;
  628.    subtitleStorageCommitBuffer();
  629. #ifdef _DEBUG
  630. dbg_printf(("Byte count: %lun",g_pSubtitleStorage->dwByteCount));
  631. dbg_printf(("Entry count: %lun",g_pSubtitleStorage->dwEntryCount));
  632. dbg_printf(("Max entry length: %un",g_pSubtitleStorage->wMaxEntryLength));
  633.    dbg_printf(("Max line length: %un",g_pSubtitleStorage->wMaxLineLength));
  634. #endif //_DEBUG
  635. return TRUE;
  636. }
  638. /////////////////////////////////////////////////////////////////////////////////////////////
  639. // Function Name : subtitleStorageStartEntry
  640. // Purpose : Opens a new subtitle entry
  641. // Input Parameters : dwStartSCLK - Display starting time (SCLK)
  642. // Return type : TRUE - on success. FALSE when out of subtitle storage memory
  643. // Description : writes the SCLK DWORD, followed by a null byte
  644. /////////////////////////////////////////////////////////////////////////////////////////////
  645. BOOL subtitleStorageStartEntry(DWORD dwStartSCLK)
  646. {
  648. dwStartSCLK = (dwStartSCLK > AUX_SUBTITLE_EARLY_DISPLAY_OFFSET) ? (dwStartSCLK - AUX_SUBTITLE_EARLY_DISPLAY_OFFSET) : 0;
  649. #ifdef AUX_SUBTITLES_INDEX
  650.    updateSubtitlesIndex(g_pSubtitleStorage->dwCurrentStorageOffset +
  651.     g_pSubtitleStorage->wBufferPos, dwStartSCLK);
  652. #endif // AUX_SUBTITLES_INDEX
  653. if (!subtitleStorageWriteDWORD(dwStartSCLK))
  654. return FALSE;
  655. if (!subtitleStorageWriteByte(0))
  656. return FALSE;
  657. #ifdef _DEBUG
  658. g_pSubtitleStorage->wCurrentEntryLength = 0;
  659.    g_pSubtitleStorage->wCurrentLineLength = 0;
  660. #endif //_DEBUG
  661. return TRUE;
  662. }
  664. /////////////////////////////////////////////////////////////////////////////////////////////
  665. // Function Name : subtitleStorageEndEntry
  666. // Purpose : Closes a subtitle entry
  667. // Input Parameters : dwEndSCLK - Display starting time (SCLK)
  668. // Return type : TRUE - on success. FALSE when out of subtitle storage memory
  669. // Description : writes a null byte, followed by the SCLK DWORD.
  670. /////////////////////////////////////////////////////////////////////////////////////////////
  671. BOOL subtitleStorageEndEntry(DWORD dwEndSCLK)
  672. {
  673. dwEndSCLK = (dwEndSCLK > AUX_SUBTITLE_EARLY_DISPLAY_OFFSET) ? (dwEndSCLK - AUX_SUBTITLE_EARLY_DISPLAY_OFFSET) : 0;
  674. #ifdef _DEBUG
  675. g_pSubtitleStorage->dwEntryCount++;
  676. if ( g_pSubtitleStorage->wCurrentEntryLength > g_pSubtitleStorage->wMaxEntryLength )
  677. g_pSubtitleStorage->wMaxEntryLength = g_pSubtitleStorage->wCurrentEntryLength;
  678.    if ( g_pSubtitleStorage->wCurrentLineLength > g_pSubtitleStorage->wMaxLineLength )
  679. g_pSubtitleStorage->wMaxLineLength = g_pSubtitleStorage->wCurrentLineLength;
  680. #endif //_DEBUG
  681. if (!subtitleStorageWriteByte(0))
  682. return FALSE;
  683. if (!subtitleStorageWriteDWORD(dwEndSCLK))
  684. return FALSE;
  685. return TRUE;
  686. }
  688. /////////////////////////////////////////////////////////////////////////////////////////////
  689. // Function Name : subtitleStorageWriteByte
  690. // Purpose : Writes a byte to the subtitle storage memory
  691. // Input Parameters : b       - the byte to be stored
  692. // Return type : TRUE - on success. FALSE when out of subtitle storage memory
  693. // Description : writes the byte to the internal buffer. when full - writes the buffer
  694. //                  to the subtitle storage memory
  695. /////////////////////////////////////////////////////////////////////////////////////////////
  696. BOOL subtitleStorageWriteByte(BYTE b)
  697. {
  698. if (g_pSubtitleStorage->dwCurrentStorageOffset + g_pSubtitleStorage->wBufferPos  >= SUBTITLES_MEMORY_SIZE)
  699. return FALSE;
  700. g_pSubtitleStorage->baBuffer[g_pSubtitleStorage->wBufferPos++] = b;
  701. if ( g_pSubtitleStorage->wBufferPos >= STORAGE_INTERFACE_BUFFER_SIZE )
  702. subtitleStorageCommitBuffer();
  703. #ifdef _DEBUG
  704. g_pSubtitleStorage->dwByteCount++;
  705.    g_pSubtitleStorage->wCurrentEntryLength++;
  706.    g_pSubtitleStorage->wCurrentLineLength++;
  707. #endif
  708. return TRUE;
  709. }
  711. /////////////////////////////////////////////////////////////////////////////////////////////
  712. // Function Name : subtitleStorageWriteDWORD
  713. // Purpose : Writes a double word to the subtitle storage memory
  714. // Input Parameters : dw       - the dword to be stored
  715. // Return type : TRUE - on success. FALSE when out of subtitle storage memory
  716. // Description : writes the word to the internal buffer, byte by byte. when
  717. //                  the internal buffer is full - writes the buffer
  718. //                  to the subtitle storage memory
  719. /////////////////////////////////////////////////////////////////////////////////////////////
  720. BOOL subtitleStorageWriteDWORD(DWORD dw)
  721. {
  722. int i;
  723. for (i=0;i<4;i++) {
  724.       // write the high byte
  725. if (!subtitleStorageWriteByte(dw >> 24 ))
  726. return FALSE;
  727. dw = dw << 8 ;
  728. }
  729. return TRUE;
  730. }
  733. /////////////////////////////////////////////////////////////////////////////////////////////
  734. // Function Name : subtitleStorageCommitBuffer
  735. // Purpose : Internal Write the internal buffer to memory
  736. // Return type : void
  737. // Description : uses sc_SetBytes to write the buffer to subtitle memory. resets wBufferPos
  738. /////////////////////////////////////////////////////////////////////////////////////////////
  739. void subtitleStorageCommitBuffer(void)
  740. {
  741.    wai_sem(SEM_DRAM_ID);
  742. // Robin_0527_2004_A
  743.    I49_WriteDRAMData (CALC_SUBTITLE_ADDRESS(_mpeg4ExternalSubtitleAddr , g_pSubtitleStorage->dwCurrentStorageOffset),
  744.      (UINT16*)g_pSubtitleStorage->baBuffer, STORAGE_INTERFACE_BUFFER_SIZE/2);
  745.    sig_sem(SEM_DRAM_ID);
  746. g_pSubtitleStorage->dwCurrentStorageOffset += g_pSubtitleStorage->wBufferPos;
  747.    g_pSubtitleStorage->wBufferPos = 0;
  748. }
  750. /////////////////////////////////////////////////////////////////////////////////////////////
  751. // Function Name : subtitleStorageGetSubtitle
  752. // Purpose : Get a subtitle string and the end sclk count
  753. // Output Parameters:  dwEndSCLK - The time for stopping the display of this subtitle in SCLK count
  754. // Return type : TRUE on success, FALSE if string is too long to fit in buffer
  755. // Description : Copies the subtitle string from subtitles storage memory to
  756. //                  the scratch pad. The string is copied as it was in the subtitles file,
  757. //   except for conversion of formatting symbols. Conversion to Unicode or any
  758. //                  other format the OSD module requires, is likely to be language-dependant,
  759. //                  and should be performed by the calling function if necessary.
  760. //   The time for displaying the returned subtitle should be determined beforehand,
  761. //                  and this function should be called when this time is reached. The end time is
  762. //                  returned by this function.
  763. /////////////////////////////////////////////////////////////////////////////////////////////
  764. BOOL subtitleStorageGetSubtitle(DWORD *dwEndSCLK)
  765. {
  766. int sc_pos = 0;
  767.    int copyStart;
  768.    BYTE c;
  769.    int i=0;
  771.    // skip the null byte
  772. subtitleStorageReadByte(&c);
  774. // save start address of the segment to be written to the scratch pad
  775. copyStart = g_pSubtitleStorage->wBufferPos;
  776.    do
  777.    {
  778.   c = g_pSubtitleStorage->baBuffer[g_pSubtitleStorage->wBufferPos++];
  779. if ( g_pSubtitleStorage->wBufferPos >= STORAGE_INTERFACE_BUFFER_SIZE )
  780.       {
  781.        sc_SetBytes(SC_AUX_SUBTITLES_STRINGS_ADDR,
  782.           sc_pos,
  783.                      g_pSubtitleStorage->wBufferPos - copyStart,
  784.                      &(g_pSubtitleStorage->baBuffer[copyStart]) );
  785.          sc_pos += g_pSubtitleStorage->wBufferPos - copyStart;
  786. subtitleStorageFillBuffer();
  787.          copyStart = g_pSubtitleStorage->wBufferPos;
  788.       }
  789.       i++;
  790.    }
  791.    while ( '' != c && i < SUBTITLE_STRING_SC_SZ_B );
  793.    // if subtitle text is longer than the subtitle string buffer
  794.    if ( i == SUBTITLE_STRING_SC_SZ_B ) {
  795.       // read until the terminating null
  796.     while ( '' != c )
  797.        subtitleStorageReadByte(&c);
  799. // terminate the string
  800. if (copyStart != g_pSubtitleStorage->wBufferPos)
  801.       {
  802. // the end of the string wasn't written to the scratch pad yet
  803.        c = g_pSubtitleStorage->baBuffer[g_pSubtitleStorage->wBufferPos-1];
  804.          g_pSubtitleStorage->baBuffer[g_pSubtitleStorage->wBufferPos-1] = '';
  805.       }
  806.       else
  807.       {
  808. BYTE tmp[2];
  809.        // the last char was alraedy written, so write directly to the scratch pad
  810. sc_GetBytes(SC_AUX_SUBTITLES_STRINGS_ADDR,
  811.       (sc_pos)-1,
  812.                2,
  813.                tmp );
  814.                tmp[1]='';
  815. sc_SetBytes(SC_AUX_SUBTITLES_STRINGS_ADDR,
  816.       (sc_pos)-1,
  817.                2,
  818.                tmp );
  819.       }
  820.       dbg_printf(("End SCLK %lun",*dwEndSCLK));
  821.    }
  823. // if some characters weren't yet copied to the scratch pad
  824. if (copyStart != g_pSubtitleStorage->wBufferPos)
  825.    {
  826.    sc_SetBytes(SC_AUX_SUBTITLES_STRINGS_ADDR,
  827.       sc_pos,
  828.                 g_pSubtitleStorage->wBufferPos - copyStart,
  829.                 &(g_pSubtitleStorage->baBuffer[copyStart]) );
  830. if ( i == SUBTITLE_STRING_SC_SZ_B )
  831.       {
  832. // resotre the character that was replaced by ''
  833.     g_pSubtitleStorage->baBuffer[g_pSubtitleStorage->wBufferPos-1] = c;
  834.       }
  835.    }
  836.    
  837.    // read end SCLK value
  838.    subtitleStorageReadDWORD(dwEndSCLK);
  840.    return ( i != SUBTITLE_STRING_SC_SZ_B ); 
  841. }
  843. /////////////////////////////////////////////////////////////////////////////////////////////
  844. // Function Name : subtitleStorageSkipSubtitle
  845. // Purpose : Go to the next subtitle, and get the start SCLK count
  846. // Output Parameters: dwStartSCLK - Start display time, as SCLK count
  847. // Description : 
  848. /////////////////////////////////////////////////////////////////////////////////////////////
  849. BOOL subtitleStorageSkipSubtitle(DWORD *dwStartSCLK)
  850. {
  851.    BYTE c;
  852.    // skip the null byte
  853.    subtitleStorageReadByte(&c);
  855.    // skip the string
  856.    do
  857.    {
  858.     subtitleStorageReadByte(&c);
  859.    } while ( c != '' );
  861.    // skip end SCLK value
  862.    subtitleStorageReadDWORD(dwStartSCLK);
  863. return subtitleStorageGetStartTime(dwStartSCLK);
  864. }
  868. /////////////////////////////////////////////////////////////////////////////////////////////
  869. // Function Name : subtitleStorageGetStartTime
  870. // Purpose : Get the start SCLK count of the current subtitle
  871. // Output Parameters: dwStartSCLK - Start display time, as SCLK count
  872. // Return type : FALSE if there are no more subtitles. TRUE otherwise
  873. // Description : Reads the start SCLK count for this subtitle. If there are no more subtitle,
  874. //                  FALSE is returned, and also the value of dwStartSCLK is LAST_SUBTITLE_MARKER
  875. //   which is set to be the max possible value of the SCLK
  876. /////////////////////////////////////////////////////////////////////////////////////////////
  877. BOOL subtitleStorageGetStartTime(DWORD *dwStartSCLK)
  878. {
  879. subtitleStorageReadDWORD(dwStartSCLK);
  880.    if (LAST_SUBTITLE_MARKER == *dwStartSCLK) {
  881.     subtitleStorageRewindBytes(4);
  882.       return FALSE;
  883.    }
  884.     return TRUE;
  885. }
  887. /////////////////////////////////////////////////////////////////////////////////////////////
  888. // Function Name : subtitleStorageFillBuffer
  889. // Purpose : Internal function for reading from the subtitles memory in to the internal buffer
  890. // Input Parameters : storage - handle to a storage struct
  891. // Return type : void
  892. // Description : uses sc_GetBytes to write the buffer to subtitle memory. resets wBufferPos
  893. /////////////////////////////////////////////////////////////////////////////////////////////
  894. void subtitleStorageFillBuffer(void)
  895. {
  896.    wai_sem(SEM_DRAM_ID);
  897.    I49_ReadDRAMData(CALC_SUBTITLE_ADDRESS(_mpeg4ExternalSubtitleAddr , g_pSubtitleStorage->dwCurrentStorageOffset),
  898.                         (UINT16 *)g_pSubtitleStorage->baBuffer , STORAGE_INTERFACE_BUFFER_SIZE/2);
  899.    sig_sem(SEM_DRAM_ID);
  900. g_pSubtitleStorage->dwCurrentStorageOffset += STORAGE_INTERFACE_BUFFER_SIZE;
  901.    g_pSubtitleStorage->wBufferPos = 0;
  902. }
  904. /////////////////////////////////////////////////////////////////////////////////////////////
  905. // Function Name : subtitleStorageReadByte
  906. // Purpose : Reads a byte to the subtitle storage memory
  907. // Input Parameters : b       - place to store the byte
  908. // Return type : void
  909. // Description : Reads the byte from the internal buffer. when empty - fills the buffer
  910. /////////////////////////////////////////////////////////////////////////////////////////////
  911. void subtitleStorageReadByte(BYTE *b)
  912. {
  913. *b = g_pSubtitleStorage->baBuffer[g_pSubtitleStorage->wBufferPos++];
  914. if ( g_pSubtitleStorage->wBufferPos >= STORAGE_INTERFACE_BUFFER_SIZE )
  915. subtitleStorageFillBuffer();
  916. }
  917. /////////////////////////////////////////////////////////////////////////////////////////////
  918. // Function Name : subtitleStorageReadDWORD
  919. // Purpose : Reads a byte to the subtitle storage memory
  920. // Input Parameters : b       - place to store the DWOR
  921. // Return type : void
  922. // Description : Reads the DWORD byte by byte using subtitleStorageReadByte
  923. /////////////////////////////////////////////////////////////////////////////////////////////
  924. void subtitleStorageReadDWORD(DWORD *dw)
  925. {
  926. int i;
  927.    BYTE b;
  929.    *dw = 0;
  930. for (i=0;i<4;i++) {
  931. subtitleStorageReadByte(&b);
  932.       (*dw) = (*dw) << 8 ;
  933.       (*dw) += (DWORD)b;
  934. }
  935. }
  937. /////////////////////////////////////////////////////////////////////////////////////////////
  938. // Function Name  : subtitleStorageRewindBytes
  939. // Purpose  : Rewinds the subtitles storage pointer
  940. // Input Parameters: count   - number of bytes to rewind
  941. // Return type : FALSE when attempting to rewind beyond the start of the subtitles storage
  942. //   TRUE otherwise.
  943. // Description : Checks if the requested position is currently in the buffer, and updates
  944. //                  internal pointers if so. Otherwise, reads required data from the SDRAM
  945. /////////////////////////////////////////////////////////////////////////////////////////////
  946. BOOL subtitleStorageRewindBytes(WORD count)
  947. {
  948.    BYTE bAlign=0;
  950. if ( g_pSubtitleStorage->dwCurrentStorageOffset - STORAGE_INTERFACE_BUFFER_SIZE
  951.     + g_pSubtitleStorage->wBufferPos < count )
  952.     return FALSE;
  953.    else if ( g_pSubtitleStorage->wBufferPos >= count )
  954.     g_pSubtitleStorage->wBufferPos -= count;
  955.    else {
  956.     g_pSubtitleStorage->dwCurrentStorageOffset -= (STORAGE_INTERFACE_BUFFER_SIZE + count - g_pSubtitleStorage->wBufferPos);
  957.       g_pSubtitleStorage->wBufferPos=0;
  958.       bAlign = g_pSubtitleStorage->dwCurrentStorageOffset & 0x3 ;
  959.     g_pSubtitleStorage->dwCurrentStorageOffset -= bAlign;
  960.       subtitleStorageFillBuffer();
  961.       g_pSubtitleStorage->wBufferPos = bAlign;
  962.    }
  963.    return TRUE;
  964. }
  966. /////////////////////////////////////////////////////////////////////////////////////////////
  967. // Function Name  : checkAndHandleAuxSubtitles
  968. // Purpose  : Reads subtitles from memory, and sends them to the UI
  969. // when it's time to display them.
  970. // Input Parameters: dwCurrentTime - current SCLK count.
  971. // Return type : void
  972. // Description : Checks if the current time is later than the previously
  973. //                  noted "next update time". If it's time to start displaying
  974. //   a new subtitle, and the UI task has finished dealing with
  975. //   the previous subtitle, write the new subtitle text to a buffer
  976. //   and send an event to the UI - to start displaying it.
  977. //   if it's time to stop displaying a subtitle - send a proper
  978. //   event to the UI.
  979. /////////////////////////////////////////////////////////////////////////////////////////////
  980. void checkAndHandleAuxSubtitles(DWORD dwCurrentTime)
  981. {
  982.    if ( !IS_AUX_SUBTITLE_PLAY_MODE )
  983.     return;
  985. while ( dwCurrentTime >= g_dwNextSubtitleUpdateSCLK )
  986.    {
  987.     if ( IS_AUX_SUBTITLE_START_DISPLAY ) {
  988.        // the start SCLK was read, and now this time was reached.
  989.          // display the subtitle
  991.          // if the UI task finished with the previous subtitles, read a new one and tell the UI
  992.          if ( FALSE == IS_AUX_SUBTITLE_BUFFER_LOCKED ) {
  993.           if ( FALSE == subtitleStorageGetSubtitle(&g_dwNextSubtitleUpdateSCLK)) {
  994.           dbg_printf(("Error - subtitle too longn"));
  995.           }
  996.             // check if the end time of new subtitle has passed too
  997.             if (g_dwNextSubtitleUpdateSCLK < dwCurrentTime) {
  998.              subtitleStorageGetStartTime(&g_dwNextSubtitleUpdateSCLK);
  999.             }
  1000.             // tell the UI to display the string
  1001.             else {
  1002.                SET_AUX_SUBTITLE_BUFFER_LOCKED(TRUE);
  1003.              ie_send(IE_UI_START_DISPLAY_AUX_SUBTITLE);
  1004.                SET_AUX_SUBTITLE_START_DISPLAY(FALSE);
  1005.             }
  1006. }
  1007.          else {
  1008.           subtitleStorageSkipSubtitle(&g_dwNextSubtitleUpdateSCLK);
  1009.          }
  1010.       }
  1011.       else {
  1012.        // the subtitle was displayed, and now it's the time to stop displaying
  1013.          subtitleStorageGetStartTime(&g_dwNextSubtitleUpdateSCLK);
  1014.          // avoid sending the stop event when the next subtitle should be
  1015.          // displayed immidiately
  1016.          if ( dwCurrentTime < g_dwNextSubtitleUpdateSCLK )
  1017.           ie_send(IE_UI_STOP_DISPLAY_AUX_SUBTITLE);
  1018.          SET_AUX_SUBTITLE_START_DISPLAY(TRUE);
  1019.       }
  1020.    }
  1021. }
  1023. /////////////////////////////////////////////////////////////////////////////////////////////
  1024. // Function Name  : unlockAuxSubtitlesStringBuffer
  1025. // Purpose  : unlock the string buffer
  1026. // Return type : void
  1027. // Description : After the UI receives an event from the core task to display subtitles
  1028. //                  and processes the text in the subtitle string buffer, it calls this function
  1029. //   to designate that it no longer needs the data in the subtitles string buffer.
  1030. //   The core task can fill the buffer only when it's unlocked, and it locks
  1031. //   it before sending display subtitles event to the UI task.
  1032. /////////////////////////////////////////////////////////////////////////////////////////////
  1033. void unlockAuxSubtitlesStringBuffer(void)
  1034. {
  1035. SET_AUX_SUBTITLE_BUFFER_LOCKED(FALSE);
  1036. }
  1039. /////////////////////////////////////////////////////////////////////////////////////////////
  1040. // Function Name  : updateSubtitlesIndex
  1041. // Purpose  : add a new entry to the subtitles index
  1042. // Input parameters: dwAddress   - offest in bytes of the new entry, from the start of
  1043. //   the subtitles storage memory.
  1044. // dwStartSCLK - start SCLK count for the new subtitle.
  1045. // Return type : void
  1046. // Description : This function is called for each new subtitles entry. It checks if
  1047. //   the entry should be indexed, and stores its time and address if it
  1048. //   should. In any given time, there's a uniform interval (in subtitle
  1049. //   entries) between each index entry. When the index is full, half of
  1050. //                  the entries are discarded and the interval is multiplied by 2.
  1051. /////////////////////////////////////////////////////////////////////////////////////////////
  1052. #ifdef  AUX_SUBTITLES_INDEX
  1053. void updateSubtitlesIndex(DWORD dwAddress, DWORD dwStartSCLK)
  1054. {
  1055.    int i;
  1057.    g_pSubtitleIndex->wSubtitlesModulu ++;
  1059.    if ( g_pSubtitleIndex->wSubtitlesModulu == g_pSubtitleIndex->wInterval ) {
  1060.     if ( g_pSubtitleIndex->bIndexPosition == SUBTITLE_INDEX_ENTRIES ) {
  1061.        for ( i=1 ; i< SUBTITLE_INDEX_ENTRIES ; i +=2 ) {
  1062.           g_pSubtitleIndex->entry[i>>1].dwAddress = g_pSubtitleIndex->entry[i].dwAddress;
  1063.           g_pSubtitleIndex->entry[i>>1].dwStartTime = g_pSubtitleIndex->entry[i].dwStartTime;
  1064.          }
  1065. g_pSubtitleIndex->wInterval = g_pSubtitleIndex->wInterval << 1;
  1066.          g_pSubtitleIndex->bIndexPosition = SUBTITLE_INDEX_ENTRIES / 2;
  1067.       }
  1068.     g_pSubtitleIndex->entry[g_pSubtitleIndex->bIndexPosition].dwAddress = dwAddress;
  1069.       g_pSubtitleIndex->entry[g_pSubtitleIndex->bIndexPosition++].dwStartTime = dwStartSCLK;
  1070.       g_pSubtitleIndex->wSubtitlesModulu = 0;
  1071.    }
  1072. }
  1073. #endif // AUX_SUBTITLES_INDEX
  1075. /////////////////////////////////////////////////////////////////////////////////////////////
  1076. // Function Name  : subtitleGoToTime
  1077. // Purpose  : Jump to a new time in the subtitle storage
  1078. // Input parameters: dwCurrentTime - the new time
  1079. // Return type :  void
  1080. // Description :  After FF/FB/Goto, this function is used to set the next subtitle to be
  1081. //                   the 1 right before the new time.
  1082. /////////////////////////////////////////////////////////////////////////////////////////////
  1083. void subtitleGoToTime(DWORD dwCurrentTime)
  1084. {
  1085. #ifdef DEBUG_AUX_SUBTITLES
  1086. DWORD dwStart;
  1087.    DWORD dwEnd;
  1088.    dwStart=gen_timer();
  1089. #endif
  1091. // <<< Robin_0318_2005, need re-allocate the memory 
  1092. _allocateStorageInterface();
  1093. // >>> Robin_0318_2005
  1094.     // WARNING: disable next 4 lines before uncommenting the next section
  1095.    g_pSubtitleStorage->dwCurrentStorageOffset = 0;
  1096.  g_pSubtitleStorage->wBufferPos=0;
  1097.     subtitleStorageFillBuffer();
  1098.     subtitleStorageGetStartTime(&g_dwNextSubtitleUpdateSCLK);
  1100.     /* Disabled until time can be determined before playback starts.
  1102.     // look for the first indexed entry with later time
  1103.     for (i=0 ; g_pSubtitleIndex->entry[i].dwStartTime<dwCurrentTime && i < g_pSubtitleIndex->bIndexPosition ; i++)
  1104.     {
  1105.     }
  1107.     // start search from the previous indexed entry, or from the beginning of
  1108.     // subtitle memory if the 1st indexed entry is too late
  1109.     dwPreviousAddress = i > 1 ? g_pSubtitleIndex->entry[i-1].dwAddress : 0 ;
  1111.     g_pSubtitleStorage->dwCurrentStorageOffset = dwPreviousAddress ;
  1112.  g_pSubtitleStorage->wBufferPos=0;
  1113.     subtitleStorageFillBuffer();
  1116.     // The time was indexed, so this function call only comes to advances
  1117.     // the reading pointer.
  1118.     subtitleStorageGetStartTime(&g_dwNextSubtitleUpdateSCLK);
  1119.     // search subtitle memory sequentially for the last subtitle before
  1120.     // the current time
  1121.     while (1)
  1122.     {
  1123.      if ( g_dwNextSubtitleUpdateSCLK >= dwCurrentTime )
  1124.      break;
  1125.       dwPreviousAddress = g_pSubtitleStorage->dwCurrentStorageOffset +
  1126.           g_pSubtitleStorage->wBufferPos - STORAGE_INTERFACE_BUFFER_SIZE - 4;
  1128.      subtitleStorageSkipSubtitle(&g_dwNextSubtitleUpdateSCLK);
  1129.     }
  1131.     g_pSubtitleStorage->dwCurrentStorageOffset = dwPreviousAddress ;
  1132.  g_pSubtitleStorage->wBufferPos=0;
  1133.     subtitleStorageFillBuffer();
  1134.     subtitleStorageGetStartTime(&g_dwNextSubtitleUpdateSCLK); */
  1137.     SET_AUX_SUBTITLE_START_DISPLAY(TRUE);
  1138. #ifdef DEBUG_AUX_SUBTITLES
  1139.    dwEnd=gen_timer();
  1140.    dbg_printf(("Subtitles seek time: %lun",dwEnd-dwStart));
  1141. #endif
  1143. }
  1145. /////////////////////////////////////////////////////////////////////////////////////////////
  1146. // Function Name  : setSubtitlesPlayMode
  1147. // Purpose  : Sets the play mode for subtitles - whether the core task should
  1148. //                   check for new subtitles or not.
  1149. // Input parameters: mode - whether play mode is on
  1150. // Return type :  void
  1151. // Description :  Before using FF/FB/Goto, play mode should be set to FALSE so that the
  1152. // core task won't try to search for subtitles. After FF/FB/Goto is done
  1153. // and subtitleGoToTime is called, play more should be set to TRUE.
  1154. /////////////////////////////////////////////////////////////////////////////////////////////
  1155. void setSubtitlesPlayMode(BOOL mode)
  1156. {
  1157.    // transition from scanning to normal playback
  1158.    /*
  1159.    if (!IS_AUX_SUBTITLE_PLAY_MODE && mode == TRUE) {
  1160.     //SET_AUX_SUBTITLE_PERFORM_SEEK(TRUE);
  1161.    } */
  1162.    SET_AUX_SUBTITLE_PLAY_MODE(mode);
  1163.    dbg_printf(("Subtitles mode - %dn",mode));
  1164. }
  1166. /////////////////////////////////////////////////////////////////////////////////////////////
  1167. // Function Name  : stopDisplayAuxSubtitles
  1168. // Purpose  : notify the UI to stop displaying the current subtitle
  1169. // Return type :  void
  1170. // Description :
  1171. /////////////////////////////////////////////////////////////////////////////////////////////
  1172. void stopDisplayAuxSubtitles(void)
  1173. {
  1174. ie_send(IE_UI_STOP_DISPLAY_AUX_SUBTITLE);
  1176. //Stivenz_1115_04: Memory optimization: Move g_SubtitleStorage and g_SubtitleIndex to heap.
  1177. _freeStorageInterfaceAndIndex();
  1178. }
  1180. BOOL areAuxSubtitlePresent(void)
  1181. {
  1182. return IS_AUX_SUBTITLE_AVAILABE;
  1183. }
  1184. // <<< Robin_0907_2004
  1185. BOOL areAuxSubtitleExist(void)
  1186. {
  1187. return IS_AUX_SUBTITLE_EXIST;
  1188. }
  1189. // >>> Robin_0907_2004
  1190. /*
  1191. void switchBytesInWString(LPSTR str)
  1192. {
  1193. WCHAR tmp;
  1194. WCHAR *p = (WCHAR *)str;
  1196.    while (*p != NULL )
  1197.    {
  1198.     tmp = *p;
  1199.       *p= (((tmp&0xff)<<8) | ((tmp&0xff00)>>8));
  1200.       p++;
  1201.    }
  1202. }
  1203. */
  1204. // <<< Stivenz_1115_2004: Move g_SubtitleStorage to heap to save memory.
  1205. ////////////////////////////////////////////////////////////////////////////////////////////
  1206. // Function Name  : _allocateStorageInterface
  1207. // Purpose  : malloc memory for auxiliary subtitle storage interface.
  1208. // Return type :  TRUE if success, otherwise FASLE
  1209. // Description :this function is only for memory optimization.
  1210. /////////////////////////////////////////////////////////////////////////////////////////////
  1211. static BOOL _allocateStorageInterface(void)
  1212. {
  1214. if( NULL == g_pSubtitleStorage)
  1215. {
  1216. //dbg_printf(("initAuxSubtitles() malloc for g_pSubtitleStorage.n"));
  1217. g_pSubtitleStorage = malloc(sizeof(SubtitleStorageInterface));
  1218. if( NULL == g_pSubtitleStorage)
  1219. {
  1220. tr_printf(("FATAL: initAuxSubtitles() Failed [1]: Malloc failed. Low system resource.n"));
  1221. return FALSE;
  1222. }
  1223. }
  1224. return TRUE;
  1225. }
  1227. #ifdef AUX_SUBTITLES_INDEX
  1228. ////////////////////////////////////////////////////////////////////////////////////////////
  1229. // Function Name  : _allocateStorageIndex
  1230. // Purpose  : malloc memory for auxiliary subtitle storage index.
  1231. // Return type :  TRUE if success, otherwise FASLE
  1232. // Description :this function is only for memory optimization.
  1233. /////////////////////////////////////////////////////////////////////////////////////////////
  1234. static BOOL _allocateStorageIndex(void)
  1235. {
  1236. if(NULL == g_pSubtitleIndex)
  1237. {
  1238. //dbg_printf(("initAuxSubtitles() malloc for g_pSubtitleIndex.n"));
  1239. g_pSubtitleIndex = malloc(sizeof(SubtitleStorageIndex));
  1240. if( NULL == g_pSubtitleIndex)
  1241. {
  1242. tr_printf(("FATAL: initAuxSubtitles() Failed [2]: Malloc failed. Low system resource.n"));
  1243. return FALSE;
  1244. }
  1245. }
  1246. return TRUE;
  1247. }
  1248. #endif 
  1249. ////////////////////////////////////////////////////////////////////////////////////////////
  1250. // Function Name  : _FreeStorageInterfaceAndIndex
  1251. // Purpose  : free memory of auxiliary subtitle storage interface or index .
  1252. // Return type :  TRUE if success, otherwise FASLE
  1253. // Description :this function is only for memory optimization.
  1254. /////////////////////////////////////////////////////////////////////////////////////////////
  1255. #ifdef V882_FLASH_CARD
  1256. BOOL _freeStorageInterfaceAndIndex(void)
  1257. #else
  1258. static BOOL _freeStorageInterfaceAndIndex(void)
  1259. #endif
  1260. {
  1261. SAFELY_FREE_PTR(g_pSubtitleStorage);
  1262. #ifdef AUX_SUBTITLES_INDEX
  1263. SAFELY_FREE_PTR(g_pSubtitleIndex);
  1264. #endif // AUX_SUBTITLES_INDEX
  1265. return TRUE;
  1266. }
  1267. // Stivenz_1115_2004 >>>
  1269. #ifdef IS_MP4_CAPABLE
  1270. static void _mp4SubtitleReadDRAM(UINT32 ulAddress, UINT16* pBuffer, UINT32 ulLength )
  1271. {
  1273. UINT32 ulWriteLengthFirst;
  1274. UINT32 ulWriteLngthSecond;
  1276. UINT32 ulBufferStartAddr, ulBufferEndAddr;
  1279. ulBufferStartAddr = _mpeg4InternalSubtitleBufferStartAddr * 512UL;
  1280. ulBufferEndAddr = (_mpeg4InternalSubtitleBufferStartAddr + SPB_SIZE_AVI) * 512UL;
  1283.     while(ulAddress >= ulBufferEndAddr)
  1284.    {
  1285. ulAddress -= (ulBufferEndAddr - ulBufferStartAddr);
  1286.    }
  1288.    ulWriteLengthFirst = min(ulLength, ulBufferEndAddr -ulAddress);
  1289.    ulWriteLngthSecond = ulLength - ulWriteLengthFirst;
  1291.    wai_sem(SEM_DRAM_ID);
  1293.    I49_ReadDRAMDataNSW(ulAddress, (UINT16*)pBuffer, ulWriteLengthFirst);
  1295.    
  1296.    if ( ulWriteLngthSecond != 0UL)
  1297.    {
  1298.       I49_ReadDRAMDataNSW(ulBufferStartAddr, (UINT16*)(pBuffer + ulWriteLengthFirst ), ulWriteLngthSecond );
  1299.    }
  1300.    sig_sem(SEM_DRAM_ID);
  1302.    return;
  1303. }
  1305. static void _mp4SubtitleLoadTime(UINT32 *ulTime)
  1306. {
  1307. _mp4SubtitleReadDRAM( _dwMP4SubtitleReadDRAMAddr, (UINT16*)(ulTime), 2 );
  1308. _dwMP4SubtitleReadDRAMAddr += 2;
  1310. }
  1312. static BOOL _mp4SubtitleLoadSample(void)
  1313. {
  1315. UINT32 ulSampleSize;
  1316. UINT32 ulSampleSizeInWord;
  1317. BYTE pBuffer[32];
  1318. UINT16 uiSampleCount;
  1319. UINT16 uiSampleOffset;
  1320. WORD pUnicodeBuffer[32];
  1321. WORD wLastUnicode = 0;
  1322. UINT16 uiUnicodeOffset = 0;
  1324. _mp4SubtitleReadDRAM( _dwMP4SubtitleReadDRAMAddr, (UINT16*)(&ulSampleSize), 2 );
  1325. _dwMP4SubtitleReadDRAMAddr += 2;
  1327. ulSampleSizeInWord = (ulSampleSize+1)/2;
  1329. uiSampleCount = min(ulSampleSize,SUBTITLE_STRING_SC_SZ_B); 
  1330. uiSampleOffset = 0;
  1332. while(uiSampleCount > 0)
  1333. {
  1334. UINT16 uiBufferSize;
  1335. UINT16 uiUnicodeBufferSize;
  1336. uiBufferSize = min(uiSampleCount, 32);
  1337.  
  1338. _mp4SubtitleReadDRAM( (_dwMP4SubtitleReadDRAMAddr + (uiSampleOffset/2)), (UINT16*)pBuffer, ((uiBufferSize+1)/2) );
  1340. uiUnicodeBufferSize = 0;
  1341. UTF8ToUnicode(pBuffer, pUnicodeBuffer, uiBufferSize, &wLastUnicode, &uiUnicodeBufferSize);
  1343.        sc_SetBytes(SC_AUX_SUBTITLES_STRINGS_ADDR, 2*uiUnicodeOffset, 2*uiUnicodeBufferSize, (BYTE*)(&pUnicodeBuffer[0]) );
  1345.         uiSampleOffset += uiBufferSize;
  1346. uiSampleCount -= uiBufferSize;             
  1347. uiUnicodeOffset += uiUnicodeBufferSize;
  1348. }
  1350. _dwMP4SubtitleReadDRAMAddr += ulSampleSizeInWord;
  1352. return (ulSampleSize < SUBTITLE_STRING_SC_SZ_B);
  1353. }
  1355. static void _mp4SubtitleSkipSubtitle(UINT32 *ulTime)
  1356. {
  1357. UINT32 ulSampleSize;
  1358. UINT32 ulSampleSizeInWord;
  1359. _mp4SubtitleReadDRAM( _dwMP4SubtitleReadDRAMAddr, (UINT16*)(&ulSampleSize), 2 );
  1360. _dwMP4SubtitleReadDRAMAddr += 2;
  1361. ulSampleSizeInWord = (ulSampleSize+1)/2;
  1362. _dwMP4SubtitleReadDRAMAddr += ulSampleSizeInWord;
  1363. _dwMP4SubtitleReadDRAMAddr += 2; // skip end time
  1364. _mp4SubtitleReadDRAM( _dwMP4SubtitleReadDRAMAddr, (UINT16*)(ulTime), 2 );
  1365. _dwMP4SubtitleReadDRAMAddr += 2;
  1367. }
  1369. void mp4InitSubtitles(void)
  1370. {
  1371. g_dwNextSubtitleUpdateSCLK = LAST_SUBTITLE_MARKER;
  1372. SET_AUX_SUBTITLE_START_DISPLAY(TRUE);
  1373.     SET_AUX_SUBTITLE_BUFFER_LOCKED(FALSE);
  1374.  //   SET_AUX_SUBTITLE_AVAILABE(TRUE);
  1375.  //   setSubtitlesPlayMode(TRUE);
  1376. }
  1378. void mp4CheckAndHandleSubtitle(DWORD dwCurrentTime)
  1379. {
  1380. if (_dwMP4SubtitleReadDRAMAddr == _dwMP4SubtitleWriteDRAMAddr) // no data
  1381. {
  1382. if (IS_AUX_SUBTITLE_START_DISPLAY)
  1383. return;
  1385.    if ( dwCurrentTime >= g_dwNextSubtitleUpdateSCLK )
  1386.    {
  1387. ie_send(IE_UI_STOP_DISPLAY_AUX_SUBTITLE);
  1388. g_dwNextSubtitleUpdateSCLK = LAST_SUBTITLE_MARKER;
  1389.    SET_AUX_SUBTITLE_START_DISPLAY(TRUE);
  1390.    }
  1391. return;
  1392. }
  1395. if (g_dwNextSubtitleUpdateSCLK == LAST_SUBTITLE_MARKER) // first time
  1396. _mp4SubtitleLoadTime(&g_dwNextSubtitleUpdateSCLK);
  1399. while (dwCurrentTime >= g_dwNextSubtitleUpdateSCLK)
  1400. {
  1401. if (IS_AUX_SUBTITLE_START_DISPLAY)
  1402. {
  1403. if (FALSE == IS_AUX_SUBTITLE_BUFFER_LOCKED)
  1404. {
  1405. if ( FALSE == _mp4SubtitleLoadSample())
  1406. {
  1407. dbg_printf(("Error - subtitle too longn"));
  1408. }
  1409. _mp4SubtitleLoadTime(&g_dwNextSubtitleUpdateSCLK);
  1410. if (g_dwNextSubtitleUpdateSCLK < dwCurrentTime) {
  1411. _mp4SubtitleLoadTime(&g_dwNextSubtitleUpdateSCLK);
  1412. }
  1413. else
  1414. {
  1415. SET_AUX_SUBTITLE_BUFFER_LOCKED(TRUE);
  1416.   ie_send(IE_UI_START_DISPLAY_AUX_SUBTITLE);
  1417. SET_AUX_SUBTITLE_START_DISPLAY(FALSE);
  1418. }
  1419. }
  1420. else
  1421. {
  1422. _mp4SubtitleSkipSubtitle(&g_dwNextSubtitleUpdateSCLK);
  1423. }
  1424. }
  1425. else
  1426. {
  1427.    _mp4SubtitleLoadTime(&g_dwNextSubtitleUpdateSCLK);
  1428.    if ( dwCurrentTime < g_dwNextSubtitleUpdateSCLK )
  1429.    {
  1430.   ie_send(IE_UI_STOP_DISPLAY_AUX_SUBTITLE);
  1431. }
  1432.    SET_AUX_SUBTITLE_START_DISPLAY(TRUE);
  1433. }
  1435. }
  1437. }
  1439. #endif
  1441. // Robin_0117_2005, support AVI internal text subtitle
  1442. #ifdef IS_AVI_CAPABLE
  1444. static BOOL _aviProcessInternalSubtitleText(DWORD dwStartLBA, DWORD dwFileSize)
  1445. {
  1447. BOOL bAuxSubtitle = FALSE;
  1448. SubtitleParsingFuncPtr pfParseSubtitles;
  1449. UINT16 uiCount;
  1452.     SET_AUX_SUBTITLE_AVAILABE(FALSE);
  1453.     g_dwNextSubtitleUpdateSCLK = LAST_SUBTITLE_MARKER;
  1455. for (uiCount=0;uiCount<SF_NUMBER_OF_FORMATS;uiCount++)
  1456. {
  1457. if ( NULL != availableSubtitleFormats[uiCount].pfProbe)
  1458. {
  1459. if (TRUE == availableSubtitleFormats[uiCount].pfProbe(dwStartLBA, dwFileSize))
  1460. {
  1461. pfParseSubtitles=availableSubtitleFormats[uiCount].pfParse;
  1462. bAuxSubtitle = TRUE;
  1463. break;
  1464. }
  1465. }
  1466. }
  1468. if (bAuxSubtitle == FALSE)
  1469. {
  1470. tr_printf(("_aviProcessInternalSubtitleText - Couldn't probe subtitles filen"));
  1471. return FALSE;
  1472. }
  1474. // _mpeg4ExternalSubtitleAddr = _dwMPEG4ProcessingEndAddr;
  1477.    // if so, parse it and store its content.
  1478. if ( FALSE == pfParseSubtitles(dwStartLBA,dwFileSize,_mpeg4VideoScale,_mpeg4VideoRate)) {
  1479. tr_printf(("_aviProcessInternalSubtitleText - Couldn't parse subtitles filen"));
  1480. return FALSE;
  1481. }
  1483. _dwMPEG4ProcessingEndAddr = (CALC_SUBTITLE_ADDRESS( _mpeg4ExternalSubtitleAddr, g_pSubtitleStorage->dwCurrentStorageOffset) >>9) <<9;
  1484. _dwMPEG4ProcessingEndAddr = (_dwMPEG4ProcessingEndAddr>>9)<<9;
  1485.  
  1486. dbg_printf(("Start Address of Current External Subtitle : 0x%lxn",_dwMPEG4ProcessingEndAddr));
  1488. subtitleStorageInitReading();
  1489.     subtitleStorageGetStartTime(&g_dwNextSubtitleUpdateSCLK);
  1490.     SET_AUX_SUBTITLE_START_DISPLAY(TRUE);
  1491.     SET_AUX_SUBTITLE_BUFFER_LOCKED(FALSE);
  1492.     SET_AUX_SUBTITLE_AVAILABE(TRUE);
  1493.     setSubtitlesPlayMode(TRUE);
  1495. return TRUE;
  1497. }
  1500. ////////////////////////////////////////////////////////////////////////////
  1501. // Function name : _aviParseInternalSubtileText
  1502. // Purpose : Parse the internal subtitle (Text)
  1503. // Input Parameters : 
  1504. // Return type : 
  1505. // Description : 
  1506. ////////////////////////////////////////////////////////////////////////////
  1507. BOOL aviParseInternalSubtileText()
  1508. {
  1510. DWORD  dwTextStartLBA;
  1511. DWORD  dwTextStartOffset;
  1512. CHAR  ucChunkID[4]; 
  1513. UINT16 uiStreamNumber;
  1514. DWORD dwNameSize;
  1515. DWORD dwSize;
  1517. g_dwSubtitleExtraOffset = 0;
  1519. dwTextStartLBA = _dwMPEG4ClipStartLBA + ( (_wMPEG4ClipStartOffset + _mpeg4SubtitleOffsetInAvi - FOURCC_FIELD_LENGTH) >> 11);
  1520. dwTextStartOffset = (WORD)((_wMPEG4ClipStartOffset + _mpeg4SubtitleOffsetInAvi -FOURCC_FIELD_LENGTH) % LOGICAL_BLOCK_SIZE);
  1522. if (!AuxCache_GetBytes(dwTextStartLBA, dwTextStartOffset, 4, ucChunkID))
  1523. {
  1524. dbg_printf(("_aviParseInternalSubtileText(): AuxCache_GetBytes Failedn"));
  1525. return FALSE;
  1526. }
  1528. uiStreamNumber = (ucChunkID[0] - '0')*10 + ucChunkID[1] - '0';
  1530. if (uiStreamNumber == _mpeg4SubtitleStreamID && 't' == ucChunkID[2])
  1531. {
  1532. dwTextStartOffset += 4; // **tx
  1533. dwTextStartOffset += 4; // chunk size
  1534. dwTextStartOffset += 4; // char[4]; // ’GAB2’
  1535. dwTextStartOffset += 1; // BYTE 0x00;
  1536. dwTextStartOffset += 2; // WORD 0x02; // unicode
  1537. if (!AuxCache_GetBytes(dwTextStartLBA, dwTextStartOffset, 4, &dwNameSize))
  1538. {
  1539. dbg_printf(("_aviParseInternalSubtileText(): AuxCache_GetBytes Failedn"));
  1540. return FALSE;
  1541. }
  1542. dwTextStartOffset += 4; // DWORD dwSize_name; // length of stream name in bytes
  1543. dwTextStartOffset += dwNameSize; // char name[dwSize_name]; // zero-terminated subtitle stream name encoded in UTF-16
  1544. dwTextStartOffset +=2; // WORD 0x04;
  1545. if (!AuxCache_GetBytes(dwTextStartLBA, dwTextStartOffset, 4, &dwSize))
  1546. {
  1547. dbg_printf(("_aviParseInternalSubtileText(): AuxCache_GetBytes Failedn"));
  1548. return FALSE;
  1549. }
  1550. dwTextStartOffset += 4; // DWORD dwSize; // size of SRT/SSA text file
  1551. // char data[dwSize]; // entire SRT/SSA file
  1554. dwTextStartLBA += (dwTextStartOffset
  1555. >>11);
  1556. dwTextStartOffset = dwTextStartOffset % LOGICAL_BLOCK_SIZE;
  1558. g_dwSubtitleExtraOffset = dwTextStartOffset;
  1559. return(_aviProcessInternalSubtitleText(dwTextStartLBA, dwSize));
  1561. }
  1562. else
  1563. {
  1564. return FALSE;
  1565. }
  1566. }
  1568. #endif
  1570. #endif //  USE_AUX_SUBTITLES