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

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

DVD

开发平台：

Others

AuxSubtitlesFormats_sami.c：源码内容
  1. /**************************************************************
  2.  *  AuxSubtitlesFormats_sami.c
  3.  **************************************************************
  4.  *  Description:
  5.  *  ============
  6.  *  Format specific data and functions for subtitles files.
  7.  **************************************************************/
  9. #include "Config.h" // Global Configuration - do not remove!
  11. #if  defined (USE_AUX_SUBTITLES) && defined(SUPPORT_SAMI_SUBTITLE)
  14. #ifdef _DEBUG
  15. #undef IFTRACE
  16. #ifdef DEBUG_AUX_SUBTITLES
  17. #define IFTRACE if (gTraceNavigator)
  18. #else
  19. #define IFTRACE
  20. #endif // DEBUG_AUX_SUBTITLES
  21. #include "Debugdbgmain.h"
  22. #endif // _DEBUG
  24. #include <string.h>
  25. #include "PlaycoreNav_ClipsreadTextFile.h"
  26. #include "PlaycoreNav_ClipsAuxSubtitlesCommonPrivate.h"
  27. #include "PlaycoreNav_ClipsAuxSubtitles.h"
  28. #include "PlaycoreNav_ClipsAuxSubtitlesFormats_sami.h"
  29. // <<< Robin_0907_2004
  30. //#include "PlaycoreNav_ClipsAVI_private.h"
  31. //#include "PlaycoreNav_Clipsnav_clips.h"
  32. #include "PlaycoreCoremainCoreGDef.h"
  33. #include "PlaycoreScPadScPadAlloc.h"
  35. static void parse_body(void);
  36. static void parse_style(BOOL bClass);
  37. // >>> Robin_0907_2004
  38. static void ParseAttrs(void);
  39. static void parse_class_define(char* lang_id);
  40. static BOOL get_token(int mode);
  41. static TOKEN_TYPE ScanTable(void);
  42. static BOOL next_char( char* p );
  44. #define IsWhite(C)   (c==' ' || c=='t')
  45. #define IsLetter(C)  (((c>='a' && c<='z') || (c>='A' && c<='Z')))
  47. typedef struct{
  48. TOKEN  token;
  49. textFilePtr  tfpFile;
  50. char  current_class[10];
  51. char  prefered_class[10];
  52. ULONG current_time;
  53. }SAMI_MEM;
  54. SAMI_MEM *sami_mem;
  56. const TOKEN_LUT token_lut_array[] = 
  57. {
  58. { PARAGRAPH, "p"  },
  59. { TAG_SYNC, "sync"  },
  60. { START, "start"  },
  61. { CLASS, "class" },
  62. { TAG_BR, "br"  },
  63. { TAG_SAMI, "sami"  },
  64. { TAG_END_SAMI,  "/sami"  },
  65. { TAG_BODY, "body"  },
  66. { TAG_END_BODY,  "/body"  },
  67. { TAG_STYLE, "style"  },
  68. { TAG_END_STYLE,  "/style"  },
  69. { SAMI_ID, "id"     },
  70. { LANG, "lang"  },
  71. { SAMI_FONT,            "font"      },
  72. { SAMI_FONT_COLOR,      "color"     },
  73. { SAMI_FONT_END,        "/font"     },
  74. };
  76. BOOL probeSubtitlesFileSami(DWORD dwSubtitlesFileAddress, DWORD dwSubtitlesFileSize)
  77. {
  79. if (NULL == (sami_mem = malloc(sizeof(SAMI_MEM))) )
  80. return FALSE;
  83. sami_mem->tfpFile=textFileOpen(dwSubtitlesFileAddress,dwSubtitlesFileSize);
  84. if ( NULL == sami_mem->tfpFile )
  85. {
  86. free(sami_mem);
  87. return FALSE;
  88. }
  90. if(FALSE == textFileIsCurrentChar(sami_mem->tfpFile, '<') ||
  91. FALSE == textFileIsCurrentChar(sami_mem->tfpFile, 'S') ||
  92. FALSE == textFileIsCurrentChar(sami_mem->tfpFile, 'A') ||
  93. FALSE == textFileIsCurrentChar(sami_mem->tfpFile, 'M') ||
  94. FALSE == textFileIsCurrentChar(sami_mem->tfpFile, 'I') ||
  95. FALSE == textFileIsCurrentChar(sami_mem->tfpFile, '>'))
  96. {
  97. textFileClose(sami_mem->tfpFile);
  98. free(sami_mem);
  99. return FALSE;
  100. }
  103. subtitleStorageInitWriting();
  105. while (1)
  106. {
  107. if (FALSE == get_token(NORMAL) )
  108. break;
  109. switch (sami_mem->token.type)
  110. {
  111. case NULL_TOKEN:
  112. case TAG_END_SAMI:
  113. free(sami_mem);
  114.     textFileClose(sami_mem->tfpFile);
  115. // subtitleStorageMarkLastEntry();
  116. return FALSE;
  117. case TAG_BODY:
  118. case PARAGRAPH:
  119. case TAG_SYNC:
  120. // parse_body();
  121. break;
  122. case TAG_STYLE:
  123. parse_style(TRUE);
  124. free(sami_mem);
  125. textFileClose(sami_mem->tfpFile);
  126. return TRUE;
  127. // break;
  128. default:
  129. break;
  130. }
  131. }
  133. textFileClose(sami_mem->tfpFile);
  134. free(sami_mem);
  136. // subtitleStorageMarkLastEntry();
  137. return FALSE;
  138. }
  139. // >>> Robin_0907_2004
  141. BOOL parseSubtitlesFileSami(DWORD dwSubtitlesFileAddress, DWORD dwSubtitlesFileSize,DWORD dwScale, DWORD dwRate)
  142. {
  144. if (NULL == (sami_mem = malloc(sizeof(SAMI_MEM))) )
  145. return FALSE;
  148.     memset(sami_mem,0,sizeof(SAMI_MEM));
  150. sami_mem->tfpFile=textFileOpen(dwSubtitlesFileAddress,dwSubtitlesFileSize);
  151. if ( NULL == sami_mem->tfpFile )
  152. {
  153. free(sami_mem);
  154. return FALSE;
  155. }
  157. subtitleStorageInitWriting();
  159. while (1)
  160. {
  161. if (FALSE == get_token(NORMAL) )
  162. break;
  163. switch (sami_mem->token.type)
  164. {
  165. case NULL_TOKEN:
  166. case TAG_END_SAMI:
  167. free(sami_mem);
  168.     textFileClose(sami_mem->tfpFile);
  169. subtitleStorageMarkLastEntry();
  170. return TRUE;
  171. case TAG_BODY:
  172. case PARAGRAPH:
  173. case TAG_SYNC:
  174. parse_body();
  175. break;
  176. case TAG_STYLE:
  177. // <<< Robin_0907_2004
  178. parse_style(FALSE);
  179. // >>> Robin_0907_2004
  180. break;
  181. default:
  182. break;
  183. }
  184. }
  186. textFileClose(sami_mem->tfpFile);
  187. free(sami_mem);
  189. subtitleStorageMarkLastEntry();
  190. return TRUE;
  191. }
  194. static void parse_body()
  195. {
  196. long start_time = -1;
  197. int entry_state = 0;          //Ready to write start entry
  199. while (1)
  200. {
  201. if ( FALSE == get_token(IN_BODY) )
  202. return;
  203. switch (sami_mem->token.type)
  204. {
  205. case NULL:
  206. case TAG_END_SAMI:
  207. return;
  208. case PARAGRAPH:
  209. break;
  210. case TAG_BR:
  211. if (0 == strcmp(sami_mem->current_class, sami_mem->prefered_class) ||
  212.                0 == strlen(sami_mem->current_class)  )
  213. subtitleStorageWriteByte(FORMAT_NEW_LINE);
  214. break;
  215. case TAG_END_BODY:
  216. if (entry_state == 1)
  217.        subtitleStorageEndEntry(sami_mem->current_time + 1000);
  218. break;
  219. case TAG_SYNC:
  220. start_time = sami_mem->current_time;
  221. break;
  222. case BLANK_SYNC:
  223. if (entry_state == 1)
  224. {
  225. subtitleStorageEndEntry(sami_mem->current_time);
  226. entry_state = 0;       //Ready to write start entry
  227. }
  228. break;
  229. case CONTENT_STRING:
  230. if (0 == strcmp(sami_mem->current_class, sami_mem->prefered_class) ||
  231.                0 == strlen(sami_mem->current_class)  )
  232. {
  233. int i, len = strlen(sami_mem->token.string);
  235. if (entry_state == 1 && start_time != -1)             //Ready to write end entry
  236. {
  237. subtitleStorageEndEntry(start_time);
  238. entry_state = 0;         //Ready to write start entry
  239. }
  241. if (entry_state == 0)
  242. {
  243. if (start_time == -1)      //Didn't get <SYNC Start=...>
  244. break;
  245. subtitleStorageStartEntry(start_time);
  246. entry_state = 1;         //Ready to write content
  247. }
  249. for (i = 0; i < len; i++)
  250. {
  251. subtitleStorageWriteByte(sami_mem->token.string[i]);
  252. }
  253. start_time = -1;
  254. }
  255. break;
  256. }
  257. }
  258. }
  260. // <<< Robin_0907_2004
  261. static void parse_style(BOOL bClass)
  262. {
  263. // char class_name[10], lang_id[10];
  264. char lang_id[16]; //BT0907: was lang_id[10]
  265. MPEG4SubtitleStreamInfo mpeg4SubtitleStreamInfo;
  267. while (1)
  268. {
  269. get_token(IN_STYLE);
  270. switch (sami_mem->token.type)
  271. {
  272. case NULL_TOKEN:
  273. case TAG_END_STYLE:
  274. return;
  275. case CLASS_DEFINE:
  276. if (TRUE == bClass) // store class_name
  277. {
  278. // <<< Robin_1027_2004
  279. lang_id[0] = '';
  280. parse_class_define(lang_id);
  281. if (lang_id[0] == '')
  282. continue;
  283. // >>> Robin_1027_2004
  284. // Robin_1119_2004, display SAMI subtitle language
  285. memset(&mpeg4SubtitleStreamInfo, 0, sizeof(MPEG4SubtitleStreamInfo));
  286. mpeg4SubtitleStreamInfo.streamID = NO_STREAM;
  287. mpeg4SubtitleStreamInfo.type = SAMI;
  288. strncpy(mpeg4SubtitleStreamInfo.languageCode.language, lang_id, 2);
  289. strcpy(mpeg4SubtitleStreamInfo.className, sami_mem->token.string);
  291. sc_SetBytes(SC_MPEG4_SUBTITLE_STREAM_INFO_ADDR,
  292. (SI_CLIPS_SUB_AVAILABLE_NUM * SIZE_OF_SUBTITLE_STREAM_INFO),
  293. SIZE_OF_SUBTITLE_STREAM_INFO,
  294. (BYTE*)&mpeg4SubtitleStreamInfo
  295.      );
  296.       
  297. SI_CLIPS_SUB_AVAILABLE_NUM ++;
  298. }
  299. else
  300. {
  301. sc_GetBytes(SC_MPEG4_SUBTITLE_STREAM_INFO_ADDR,
  302. (SI_CLIPS_SUB_CURRENT_DISP_IDX * SIZE_OF_SUBTITLE_STREAM_INFO),
  303. SIZE_OF_SUBTITLE_STREAM_INFO,
  304. (BYTE*)&_mpeg4SubtitleStreamInfo
  305.      );
  307. strcpy(sami_mem->prefered_class, _mpeg4SubtitleStreamInfo.className);      
  308. }
  309. // strcpy(class_name, sami_mem->token.string);
  310. // parse_class_define(lang_id);
  311. //#ifndef USE_AUX_SUBTITLES_KSC5601 //BillTang_0724_04: to support Korean also, but will cause problem if the file contains more than one subtitle
  312. // if (0 == strncmp(lang_id, "en-", 3))        //Only support English
  313. //#endif
  314. // {
  315. // strcpy(sami_mem->prefered_class, sami_mem->token.string);
  316. // }
  317. break;
  318. case STYLE_DEFINE:
  319.  if (FALSE == textFileFindString(sami_mem->tfpFile,"}",0) )
  320.   return;
  321. break;
  322. }
  323. }
  324. }
  325. // >>> Robin_0907_2004
  326. static void ParseAttrs()
  327. {
  328. char c, str[10];
  329. int i;
  330. TOKEN_TYPE attribute;
  332. while(1)
  333. {
  334. if ((attribute = ScanTable()) == NULL_TOKEN)
  335. {
  336. //eat until '>'
  337.  if (FALSE == textFileFindString(sami_mem->tfpFile,">",0) )
  338.   return;
  339.  
  340. break;
  341. }
  343. //eat until '='
  344.  if (FALSE == textFileFindString(sami_mem->tfpFile,"=",0) )
  345.   return;
  347. if (START == attribute && sami_mem->token.type == TAG_SYNC)
  348. {
  349. textFileReadNumber(sami_mem->tfpFile, &sami_mem->current_time);
  350. }
  351. else
  352. {
  353. //Consume whilte space before lang id.
  354. while(1)
  355. {
  356. if (FALSE == textFileReadChar(sami_mem->tfpFile, 1, &c))
  357. return;
  358. if ( !IsWhite(c) )
  359. {
  360. if (FALSE == textFileSeek(sami_mem->tfpFile,-1,TF_SEEK_CUR))
  361. return;
  363. break;
  364. }
  365. }
  366. //Copy class name
  367. i = 0;
  368. while(1)
  369. {
  370. if (FALSE == textFileReadChar(sami_mem->tfpFile, 1, &c))
  371. return;
  372. if ( IsWhite(c) || c=='>')
  373. {
  374. if (FALSE == textFileSeek(sami_mem->tfpFile,-1,TF_SEEK_CUR))
  375. return;
  377. break;
  378. }
  379. str[i++] = c;
  380. }
  381. str[i++] = '';
  382. if (CLASS == attribute && sami_mem->token.type == PARAGRAPH)
  383. {
  384. strcpy(sami_mem->current_class, str);
  385. }
  386. }
  387. }
  388. }
  391. static void parse_class_define(char* lang_id)
  392. {
  393. char c;
  394. int i;
  395. TOKEN_TYPE attribute;
  397.  //Consume stream until '}'
  398. // <<< Robin_1027_2004
  399.  while(1)
  400.  {
  401.  if (FALSE == textFileReadChar(sami_mem->tfpFile, 1, &c) )
  402. return;
  404.  if (IsWhite(c))
  405. continue;
  407.  if ( c == '{')
  408. break;
  409.  else
  410. return;
  411.  }
  413. // if (FALSE == textFileFindString(sami_mem->tfpFile,"{",0) )
  414. // return;
  415. // >>> Robin_1027_2004
  418. while(1)
  419. {
  420. if ((attribute = ScanTable()) == NULL_TOKEN)
  421. {
  422. //eat until '}'
  423. if (FALSE == textFileFindString(sami_mem->tfpFile,"}",0) )
  424. return;
  426. break;
  427. }
  428. if (attribute == LANG)
  429. {
  430. //eat until ':'
  431. if (FALSE == textFileFindString(sami_mem->tfpFile,":",0) )
  432. return;
  433. //Consume whilte space before lang id.
  434. while(1)
  435. {
  436. if (FALSE == textFileReadChar(sami_mem->tfpFile, 1, &c) )
  437. return;
  438. if ( !IsWhite(c) )
  439. {
  440. if (FALSE == textFileSeek(sami_mem->tfpFile,-1,TF_SEEK_CUR))
  441. return;
  443. break;
  444. }
  445. }
  446. //Copy lang id
  447. i = 0;
  448. while(1)
  449. {
  450. if (FALSE == textFileReadChar(sami_mem->tfpFile, 1, &c) )
  451. return;
  452. if ( IsWhite(c) || c==';')
  453. {
  454. if (FALSE == textFileSeek(sami_mem->tfpFile,-1,TF_SEEK_CUR))
  455. return;
  457. break;
  458. }
  459. lang_id[i++] = c;
  461. //<<<BT0907: add condition to avoid illegal op
  462. if (i ==15)
  463. break;
  464. //>>>BT0907
  465. }
  466. lang_id[i++] = '';
  467. }
  468. //eat until ';'
  469. if (FALSE == textFileFindString(sami_mem->tfpFile,";",0) )
  470. return;
  472. }
  473. }
  475. static BOOL get_token(int mode)
  476. {
  477. static LEXER_STATE lexer_state = LEX_CONTENT;
  478. int lexer_point;
  479. char c;
  481. sami_mem->token.type = UNKNOWN;
  482. lexer_point = 0;
  484. if ( FALSE == textFileReadChar(sami_mem->tfpFile, 1, &c) )
  485. {
  486. sami_mem->token.type = NULL_TOKEN;
  487. return FALSE;
  488. }
  490. while ( FALSE == textFileEOF(sami_mem->tfpFile) )
  491. {
  492. switch (lexer_state)
  493. {
  494. case LEX_CONTENT:
  495. if (c == '<')
  496. {
  497. lexer_state = LEX_GT;
  498. continue;
  499. }
  500. else if (c=='n' || c=='r')
  501. {
  502. if (lexer_point != 0)
  503. {
  504. sami_mem->token.type = CONTENT_STRING;
  505. sami_mem->token.string[lexer_point] = '';
  506. return TRUE;
  507. }
  508. break;
  509. }
  510. else if (c == ' ')
  511. {
  512. if (mode!=IN_BODY || lexer_point==0)
  513. break;
  514. }
  515. else if (c=='.')
  516. {
  517. if (mode==IN_STYLE && lexer_point==0)
  518. {
  519. while(1)
  520. {
  521. if (FALSE == textFileReadChar(sami_mem->tfpFile, 1, &c) )
  522. return FALSE;
  524. // Robin_0408_2005, for some special token: EN-USCC 
  525. if ( IsWhite(c) )
  526. {
  527. if (FALSE == textFileSeek(sami_mem->tfpFile,-1,TF_SEEK_CUR))
  528. return FALSE;
  530. break;
  531. }
  532. sami_mem->token.string[lexer_point++] = c;
  533. }
  534. sami_mem->token.type = CLASS_DEFINE;
  535. sami_mem->token.string[lexer_point] = '';
  536. return TRUE;
  537. }
  538. }
  539. else if (c=='P' || c=='#')
  540. {
  541. if (mode==IN_STYLE && lexer_point==0)
  542. {
  543. sami_mem->token.type = STYLE_DEFINE;
  544. return TRUE;
  545. }
  546. }
  547. else if (c == ';' && mode==IN_BODY)
  548. {
  549. if (0 == strncmp(sami_mem->token.string, "&nbsp", 5) )
  550. {
  551. sami_mem->token.type = BLANK_SYNC;
  552. return TRUE;
  553. }
  554. }
  555. if (mode==IN_BODY && lexer_point < (LEN_CONTENT_STR-2))
  556. sami_mem->token.string[lexer_point++] = c;
  557. break;
  558. case LEX_GT:
  559. if ( FALSE == next_char(&c) )
  560. return FALSE;
  562. if (c == '/')
  563. {
  564. lexer_state = LEX_ENDTAG;
  565. if (lexer_point != 0)
  566. {
  567. sami_mem->token.type = CONTENT_STRING;
  568. sami_mem->token.string[lexer_point] = '';
  569. return TRUE;
  570. }
  571. continue;
  572. }
  573. if (IsLetter(c))
  574. {
  575. lexer_state = LEX_STARTTAG;
  576. if (lexer_point != 0)
  577. {
  578. if (FALSE == textFileSeek(sami_mem->tfpFile,-1,TF_SEEK_CUR)) //Rewind the first character after '<'
  579. return FALSE;
  580. sami_mem->token.type = CONTENT_STRING;
  581. sami_mem->token.string[lexer_point] = '';
  582. return TRUE;
  583. }
  584. continue;
  585. }
  586. lexer_state = LEX_CONTENT;
  587. break;
  588. case LEX_ENDTAG:
  589. sami_mem->token.type = ScanTable();
  590. if (FALSE == textFileFindString(sami_mem->tfpFile,">",0) )
  591. return FALSE;
  592. lexer_state = LEX_CONTENT;
  593. if (sami_mem->token.type != UNKNOWN)
  594. return TRUE;
  595. break;
  596. case LEX_STARTTAG:
  597. sami_mem->token.type = ScanTable();
  598. if ( FALSE == next_char(&c) )
  599. return FALSE;
  600. if (c != '>' && sami_mem->token.type!=UNKNOWN)
  601. ParseAttrs();
  602. else
  603. {
  604. //eat until end of tag '>'
  605. if (FALSE == textFileFindString(sami_mem->tfpFile,">",0) )
  606. return FALSE;
  607. }
  608. lexer_state = LEX_CONTENT;
  609. if (sami_mem->token.type != UNKNOWN)
  610. return TRUE;
  611. break;
  612. }
  613. if ( FALSE == textFileReadChar(sami_mem->tfpFile, 1, &c) )
  614. {
  615. sami_mem->token.type = NULL_TOKEN;
  616. return FALSE;
  617. }
  618. }
  619. return FALSE;
  620. }
  622. static TOKEN_TYPE ScanTable()
  623. {
  624. char c, str[10];
  625. int i = 0;
  627. //Consume whilte space before attribute.
  628. while(1)
  629. {
  630. if (FALSE == textFileReadChar(sami_mem->tfpFile, 1, &c)  )
  631. return NULL_TOKEN;
  632. if ( !IsWhite(c) && (c != 'r') && (c != 'n'))
  633. {
  634. if (FALSE == textFileSeek(sami_mem->tfpFile,-1,TF_SEEK_CUR))
  635. return NULL_TOKEN;
  637. break;
  638. }
  639. }
  641. while (1)
  642. {
  643. if (FALSE == textFileReadChar(sami_mem->tfpFile, 1, &c))
  644. return NULL_TOKEN;
  645. if (c=='=' || c==':' || c=='>' || c=='{' || c=='}' || IsWhite(c) )
  646. {
  647. if (FALSE == textFileSeek(sami_mem->tfpFile,-1,TF_SEEK_CUR))
  648. return NULL_TOKEN;
  650. break;
  651. }
  652. str[i++] = c;
  653. }
  654. str[i] = '';
  656. if (i == 0)
  657. return NULL_TOKEN;
  660. strlwr(str);            //Convert to lower case
  662. for (i=0; i<(sizeof(token_lut_array)/sizeof(TOKEN_LUT)); i++)
  663. {
  664. if (0 == strcmp(str, token_lut_array[i].str))
  665. return token_lut_array[i].token;
  666. }
  667. return UNKNOWN;
  668. }
  670. static BOOL next_char( char* p )
  671. {
  672. if ( FALSE == textFileReadChar(sami_mem->tfpFile, 1, p ))
  673. return FALSE;
  674. if (FALSE == textFileSeek(sami_mem->tfpFile,-1,TF_SEEK_CUR))
  675. return FALSE;
  677. return TRUE;
  678. }
  681. #endif //defined (USE_AUX_SUBTITLES) && defined(SUPPORT_SAMI_SUBTITLE)