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

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

DVD

开发平台：

Others

Mpeg4ClipsCommon.c：源码内容
  1. /****************************************************************************************
  2.  *  Copyright (c) 2004 ZORAN Corporation, All Rights Reserved
  3.  *  THIS IS UNPUBLISHED PROPRIETARY SOURCE CODE OF ZORAN CORPORATION
  4.  *
  5.  *  File: $Workfile: Mpeg4ClipsCommon.c $             
  6.  *
  7.  * Description: 
  8.  * ============
  9.  *  MPEG4 Clips Common 
  10.  * 
  11.  * Log:
  12.  * ====
  13.  * $Revision: #12 $
  14.  * $Change: 29756 $ 
  15.  * Last Modified by $Author: robin.jiang $ at $DateTime: 2004/10/27 19:18:00 $ 
  16.  ****************************************************************************************
  17.  * Updates:
  18.  ****************************************************************************************
  19.  * $Log: /I76/I76_Common/I76_Reference/Playcore/Nav_Clips/Mpeg4ClipsCommon.c $
  20.  *
  21.  * 1 8/2/2004 RobinJ
  22.  * Created
  23.  *
  24.  ****************************************************************************************/
  26. #include "Config.h" // Global Configuration - do not remove!
  28. #ifdef _DEBUG
  29. #undef IFTRACE
  30. #define IFTRACE if (gTraceNavigator)
  31. #include "Debugdbgmain.h"
  32. #endif
  34. #include "PlaycoreNav_ClipsMpeg4ClipsCommon.h"
  35. #include "Decoderlow_levelDEC_LL_API.h"
  36. #include "PlaycoreNav_ClipsPE_Clips.h"
  37. #include "PlaycoreCoremainCoreGDef.h"
  38. //#include "PlaycoreNav_ClipsAVI_private.h"
  39. #include "Drivedrv_api.h"
  40. #include "Decoderlow_levelDEC_LL_Reg.h"
  41. #include "DecoderDEC_Set_DVP_Gen_Regs.h"
  44. #define SCR_RATE 90000L
  46. // Robin_1011_2004_D
  47. #ifdef PATCH_VIDEO_NOT_B
  48. BOOL bRequestPAL60 = FALSE;
  49. #endif
  51. extern void DEC_set_display_video_format(DEC_LL_DECODED_FRAME_RATE v_format);
  53. // Note: Any change in the following calculation might affect the accuracy of GoTo time
  54. // <<< Robin_1003_2004_B, improve the accuracy
  55. ///////////////////////////////////////////////////////////////////////////
  56. // Function name : _caclFrameOfTime
  57. // Purpose : calculate the frame number, correspond to time 
  58. // Input Parameters : wTime - Time
  59. // : dwRate - Time Rate
  60. // : dwScale - Time Scale
  61. // Output Parameters : 
  62. // Return type : DWORD
  63. ///////////////////////////////////////////////////////////////////////////
  64. WORD caclTimeOfFrame(DWORD dwFrameNumber, DWORD dwRate, DWORD dwScale)
  65. {
  66. DWORD dwTimeDelta;
  67. DWORD dwDelta;
  68. DWORD dwDelta100, dwDelta10000;
  69. DWORD dwTime;
  70. dwTimeDelta = (1000UL*dwScale)/dwRate; // in ms
  71. dwDelta = (1000UL*dwScale) - (dwTimeDelta * dwRate);
  73. // Robin_0201_2005, avoid the calculate overflow
  74. if (((10000UL*dwDelta)/10000UL) == dwDelta)
  75. {
  76. dwDelta = (10000UL*dwDelta) / dwRate;
  77. }
  78. else if (((5000UL*dwDelta)/5000UL) == dwDelta)
  79. {
  80. dwDelta = ((5000UL*dwDelta) / dwRate) * 2;
  81. }
  82. else if (((1000UL*dwDelta)/1000UL) == dwDelta)
  83. {
  84. dwDelta = ((1000UL*dwDelta) / dwRate) * 10;
  85. }
  86. else if (((100UL*dwDelta)/100UL) == dwDelta)
  87. {
  88. dwDelta = ((100UL*dwDelta) / dwRate) * 100;
  89. }
  91. dwDelta100 = dwDelta/100;
  92. dwDelta10000 = dwDelta%100;
  93. dwTime = dwFrameNumber * dwTimeDelta;
  94. dwTime += ((dwFrameNumber*dwDelta100 + ((dwFrameNumber*dwDelta10000)/100))/100);
  95. dwTime = (dwTime+500UL)/1000UL;
  96. return (WORD)dwTime;
  97. }
  98. ///////////////////////////////////////////////////////////////////////////
  99. // Function name : _caclFrameOfTime
  100. // Purpose : calculate the frame number, correspond to time 
  101. // Input Parameters : wTime - Time
  102. // : dwRate - Time Rate
  103. // : dwScale - Time Scale
  104. // Output Parameters : 
  105. // Return type : DWORD
  106. ///////////////////////////////////////////////////////////////////////////
  107. DWORD caclFrameOfTime(WORD wTime, DWORD dwRate, DWORD dwScale)
  108. {
  109. DWORD dwFrameRate;
  110. DWORD dwDelta;
  111. DWORD dwDelta100, dwDelta10000;
  112. DWORD dwFrameNumber;
  113. dwFrameRate = dwRate/dwScale;
  114. dwDelta = dwRate - (dwFrameRate*dwScale);
  116. // Robin_0201_2005, avoid the calculate overflow
  117. if (((10000UL*dwDelta)/10000UL) == dwDelta)
  118. {
  119. dwDelta = (10000UL*dwDelta)/dwScale;
  120. }
  121. else if (((5000UL*dwDelta)/5000UL) == dwDelta)
  122. {
  123. dwDelta = ((5000UL*dwDelta) / dwScale) * 2;
  124. }
  125. else if (((1000UL*dwDelta)/1000UL) == dwDelta)
  126. {
  127. dwDelta = ((1000UL*dwDelta) / dwScale) * 10;
  128. }
  129. else if (((100UL*dwDelta)/100UL) == dwDelta)
  130. {
  131. dwDelta = ((100UL*dwDelta) / dwScale) * 100;
  132. }
  134. dwDelta100 = dwDelta/100;
  135. dwDelta10000 = dwDelta%100;
  136. dwFrameNumber = wTime * dwFrameRate;
  137. dwFrameNumber += ((wTime*dwDelta100 + ((wTime*dwDelta10000)/100))/100);
  138. return dwFrameNumber;
  139. }
  140. // >>> Robin_1003_2004_B
  143. ///////////////////////////////////////////////////////////////////////////
  144. // Function name : convertFOURCCToString
  145. // Purpose : Converts 32 FOURCC bits into a string.
  146. // Input Parameters : fourcc - 32 bits representing the FOURCC.
  147. // Output Parameters: str - The string representing the FOURCC.
  148. // Return type : none
  149. ///////////////////////////////////////////////////////////////////////////
  150. void convertFOURCCToString(FOURCC forcc, LPSTR str)
  151. {
  152. str[0] = (CHAR)(forcc & 0x000000ff);
  153. str[1] = (CHAR)(forcc >> 8);
  154. str[2] = (CHAR)(forcc >> 16);
  155. str[3] = (CHAR)(forcc >> 24);
  156. }
  158. /////////////////////////////////////////////////////////////////////////////
  159. // Private Services
  160. ///////////////////////////////////////////////////////////////////////////
  161. // Function name : qwTimeDiv10000
  162. // Purpose : 64bits in unit of 100ns to 32bits in unit of ms  
  163. // Input Parameters : time - QWORD
  164. // Return type : DWORD
  165. // Description :
  166. ///////////////////////////////////////////////////////////////////////////
  167. DWORD qwTimeDiv10000(QWORD time)
  168. {
  169. DWORD temp, result;
  170. temp = (time[1] << 16) | (time[0] >> 16);
  171. result = (temp/10000UL);
  172. temp -= result * 10000UL;
  173. result <<= 16;
  174.     temp <<= 16;
  175. temp += (time[0] & 0xFFFFUL);
  176. result += (temp/10000UL);
  177. return result;
  178. }
  180. void UTF8ToUnicode(BYTE* pUTFBuffer, WORD*  pUnicodeBuffer, UINT16 uiBufferSize,  WORD* wLastUnicode, WORD* uiUnicodeBufferSize)
  181. {
  183. while(uiBufferSize--)
  184. {
  185. if ((*pUTFBuffer) < 0x80)
  186. {
  187. if ((*wLastUnicode) != 0)
  188. {
  189. *(pUnicodeBuffer++) = (*wLastUnicode);
  190. (*uiUnicodeBufferSize)++;
  191. (*wLastUnicode) = 0;
  192. }
  194. *(pUnicodeBuffer++) = (WORD)*pUTFBuffer;
  195. (*uiUnicodeBufferSize)++;
  196. }
  197. else if ((*pUTFBuffer) < 0xc0) // trail byte
  198. {
  199. (*wLastUnicode) <<= 6;
  200. (*wLastUnicode) += ((*pUTFBuffer) - 0x80);
  201. }
  202. else
  203. {
  204. if ((*wLastUnicode) != 0)
  205. {
  206. *(pUnicodeBuffer++) = (*wLastUnicode);
  207. (*uiUnicodeBufferSize)++;
  208. (*wLastUnicode) = 0;
  209. }
  211. if ((*pUTFBuffer) < 0xe0)
  212. (*wLastUnicode) = ((*pUTFBuffer) - 0xc0);
  213. else
  214. (*wLastUnicode) = ((*pUTFBuffer) - 0xe0);
  215. }
  217. pUTFBuffer++;
  218. }
  219. }
  221. ///////////////////////////////////////////////////////////////////////////
  222. // Function name : determineDivXVersion
  223. // Purpose : Determines whether the DivX version is 3, 4 or 5.
  224. // Input Parameters : uiStreamNumber - The video stream number to determine 
  225. //   its version.
  226. // Return type : The DivX version.
  227. // Description : See the SW SPEC for details.
  228. ///////////////////////////////////////////////////////////////////////////
  229. DivXVesrion determineDivXVersion(FOURCC fourccHandle, FOURCC fouccCompression)
  230. {
  232. CHAR fccHandler[FOURCC_FIELD_LENGTH];
  233. CHAR compressionType[FOURCC_FIELD_LENGTH];
  234. DivXVesrion divxVersion = DIVX_UNKNOWN;
  236. convertFOURCCToString(fourccHandle, fccHandler);
  237. convertFOURCCToString(fouccCompression, compressionType);
  240. if ( (0 == strnicmp(fccHandler, "div3", FOURCC_FIELD_LENGTH)) ||
  241. (0 == strnicmp(fccHandler, "div4", FOURCC_FIELD_LENGTH)))
  242. {
  243. divxVersion = DIVX_3_11;
  244. }
  245. else if (0 == strnicmp(fccHandler, "mp43", FOURCC_FIELD_LENGTH))
  246. {
  247. divxVersion = MP43;
  248. }
  249. else if ((0 == strnicmp(compressionType, "div3", FOURCC_FIELD_LENGTH)) ||
  250. (0 == strnicmp(compressionType, "div4", FOURCC_FIELD_LENGTH)) )
  251. {
  252. divxVersion = DIVX_3_11;
  253. }
  254. else if (0 == strnicmp(compressionType, "mp43", FOURCC_FIELD_LENGTH))
  255. {
  256. divxVersion = MP43;
  257. }
  258. else if (0 == strnicmp(compressionType, "divx", FOURCC_FIELD_LENGTH))
  259. {
  260. divxVersion = DIVX_4_12;
  261. }
  262. else if ((0 == strnicmp(compressionType, "dx50", FOURCC_FIELD_LENGTH)) ||
  263. (0 == strnicmp(compressionType, "dxsb", FOURCC_FIELD_LENGTH)))
  264. {
  265. divxVersion = DIVX_5_0;
  266. }
  267. else if (0 == strnicmp(compressionType, "xvid", FOURCC_FIELD_LENGTH))
  268. {
  269. divxVersion = XVID;
  270. }
  271. else if (0 == strnicmp(compressionType, "rmp4", FOURCC_FIELD_LENGTH))
  272. {
  273. divxVersion = RMP4;
  274. }
  275. else if (0 == strnicmp(compressionType, "mp4s", FOURCC_FIELD_LENGTH))
  276. {
  277. divxVersion = MP4S;
  278. }
  279. else if ((0 == strnicmp(compressionType, "3ivx", FOURCC_FIELD_LENGTH)) ||
  280. (0 == strnicmp(compressionType, "3iv2", FOURCC_FIELD_LENGTH)))
  281. {
  282. divxVersion = _3IVX;
  283. }
  284. else if (0 == strnicmp(compressionType, "mp4v", FOURCC_FIELD_LENGTH))
  285. {
  286. divxVersion = MP4V;
  287. }
  289. if (DIVX_UNKNOWN == divxVersion)
  290. {
  291. dbg_printf(("WARNING: Could not identify Video Codecn"));
  292. }
  293. else
  294. {
  295. dbg_printf(("Video Codec: %dn", divxVersion));
  296. }
  298. return divxVersion;
  299. }
  301. ///////////////////////////////////////////////////////////////////////////
  302. // Function name : determineAudioInfo
  303. // Purpose : Determines the audio info of a an audio stream.
  304. // Input Parameters : none
  305. // Ouput Parameters : The audio info.
  306. // Return type : TRUE if the operation succeeded, FALSE otherwise.
  307. // Description : The function determines the audio SID.
  308. ///////////////////////////////////////////////////////////////////////////
  309. BOOL determineAudioInfo(UINT8* puiAudioSid, UINT8* puiAudioSidDecoder,DWORD* dwSampleRate)
  310. {
  311. /* Check if an audio stream was found */
  313. if ((_mpeg4AudioAvailableNum == 0) || (NO_STREAM == _mpeg4AudioStreamID))
  314. {
  315. *puiAudioSid = NO_STREAM;
  316. *puiAudioSidDecoder = NoAudio;
  317. *dwSampleRate = 0;
  318. return TRUE;
  319. }
  321. /* Determine the audio stream */
  322. switch (_mpeg4AudioCodec)
  323. {
  325. case MP3:
  326. *puiAudioSid = AUDIO_STREAM_MP3;
  327. *puiAudioSidDecoder = MP3_SID;
  328. break;
  330. case AC3: 
  331. *puiAudioSid = AUDIO_STREAM_AC3;
  332. *puiAudioSidDecoder = AC3_SID;
  333. break;
  335. case MP2:
  336. *puiAudioSid = AUDIO_STREAM_MPEG;
  337. *puiAudioSidDecoder = MPEG_SID1;
  338. break;
  340. #ifdef D_ENABLE_ADPCM_SUPPORT
  341. case PCM:
  342. // <<< Robin_2004_0525_B, 
  343. // in 2X16Mbits, if PCM sample rate is greater than 48000, playback without audio 
  344. #ifdef SDRAM_2X16MBITS
  345. #ifdef NEW_2X16M_MAPPING
  346. if (_mpeg4AudioSamplesPerSec <= 48000UL)
  347. {
  348. *puiAudioSid = AUDIO_STREAM_ADPCM;
  349. *puiAudioSidDecoder = ADPCM_SID;
  350. }
  351. else
  352. #endif
  353. {
  354. dbg_printf(("PCM audio, sample rate is exceed 48K - not supported in 2X16M n"));
  355. *puiAudioSid = NO_STREAM;
  356. *puiAudioSidDecoder = NO_STREAM;
  357. // <<< Robin_0907_2004_C
  358. *dwSampleRate = 0;
  359. return TRUE;
  360. // >>> Robin_0907_2004_C
  361. }
  362. break;
  363. #endif
  364. // >>> Robin_2004_0525_B,
  366. case ADPCM:
  367. *puiAudioSid = AUDIO_STREAM_ADPCM;
  368. *puiAudioSidDecoder = ADPCM_SID;
  369. break;
  370. #endif
  372. #ifdef D_ENABLE_DIVX_WMA_SUPPORT
  373. case WMA:
  374. *puiAudioSid = AUDIO_STREAM_WMA;
  375. *puiAudioSidDecoder = WMA_SID;
  376. break;
  377. #endif
  379. #ifdef D_ENABLE_AAC_SUPPORT
  380. case AAC:
  381. *puiAudioSid = AUDIO_STREAM_AAC;
  382. *puiAudioSidDecoder = AAC_SID;
  383. break;
  384. #endif
  386. default:
  387. *puiAudioSid = NO_STREAM;
  388. *puiAudioSidDecoder = NO_STREAM;
  390. }
  392. *dwSampleRate = _mpeg4AudioSamplesPerSec;
  393. return TRUE;
  394. }
  396. AudioCodec determineAudioCodec(DWORD dwFormatTag, WORD wFormatTag, BOOL bMP4)
  397. {
  399. AudioCodec audioCodec = AUDIO_UNKNOWN;
  401. if (TRUE == bMP4) // mp4
  402. {
  403. switch (dwFormatTag)
  404. {
  405.  case MKTAG('m', 'p', '4', 'a'):
  406.   audioCodec = AAC;
  407.   break;
  409.  case MKTAG('.','m','p','3'):
  410.  case 0x6D730055UL:
  411.  case 0x5500736DUL:
  412.   audioCodec = MP3;
  413.   break;
  415.  case MKTAG('m','s',0x20,0x20):
  416.   audioCodec = AC3;
  417.   break;
  419.  case MKTAG('r','a','w',' '):
  420.  case MKTAG('s','o','w','t'):
  421.   audioCodec = PCM;
  422.   break;
  424.  case MKTAG('s','a','m','r'):
  425.  case MKTAG('s','a','w','b'):
  426.   dbg_printf(("AMR audio detected - not supportedn"));
  427. audioCodec = AUDIO_UNKNOWN;
  428. break;
  430.  case MKTAG('i','m','a','4'):
  431.   dbg_printf(("IMA-4 ADPCM audio detected - not supportedn"));
  432. audioCodec = AUDIO_UNKNOWN;
  433. break;
  434.  
  435.  default:
  436. dbg_printf(("Unknown audio detected- not supportedn"));
  437. audioCodec = AUDIO_UNKNOWN;
  438. }
  439. }
  440. else // avi, asf
  441. {
  442. switch (wFormatTag)
  443. {
  444. case MP3_AUDIO_SID:
  445. audioCodec = MP3;
  446. break;
  448. case AC3_AUDIO_SID: 
  449. audioCodec = AC3;
  450. break;
  452. case MPEG_AUDIO_SID:
  453. audioCodec = MP2;
  454. break;
  456. case PCM_AUDIO_SID:
  457. audioCodec = PCM;
  458. break;
  460. case ADPCM_MS_AUDIO_SID:
  461. audioCodec = ADPCM;
  462. break;
  464. case PCM_ALAW_AUDIO_SID:
  465. case PCM_MULAW_AUDIO_SID:
  466. dbg_printf(("PCM audio detected - not supportedn"));
  467. audioCodec = AUDIO_UNKNOWN;
  468. break;
  470. case ADPCM_IMA_WAV_AUDIO_SID:
  471. case ADPCM_IMA_DK4_AUDIO_SID:
  472. case ADPCM_IMA_DK3_AUDIO_SID:
  473. dbg_printf(("ADPCM audio detected - not supportedn"));
  474. audioCodec = AUDIO_UNKNOWN;
  475. break;
  477. case WMAV2_AUDIO_SID:
  478. audioCodec = WMA;
  479. break;
  481. case WMAV1_AUDIO_SID:
  482. dbg_printf(("WMA V1 audio detected - not supportedn"));
  483. audioCodec = AUDIO_UNKNOWN;
  484. break;
  486. default:
  487. dbg_printf(("Unknown audio detected- not supportedn"));
  488. audioCodec = AUDIO_UNKNOWN;
  489. }
  490. }
  492. if (AUDIO_UNKNOWN == audioCodec)
  493. {
  494. dbg_printf(("WARNING: Could not identify Audio Codecn"));
  495. }
  496. else
  497. {
  498. dbg_printf(("Audio Codec: %dn", audioCodec));
  499. }
  500.     return audioCodec;
  501. }
  502. ///////////////////////////////////////////////////////////////////////////
  503. // Function name : prePlayProcessing
  504. // Purpose : Calculate and send to the DVP the AVI file
  505. //   parameters.
  506. // Input Parameters : 
  507. // Return type :
  508. // Description :
  509. ///////////////////////////////////////////////////////////////////////////
  510. void prePlayProcessing(DWORD dwSamplingRate, UINT8 uiAudioSid,
  511.    UINT8 uiAudioSIDDecoder, UINT8 uiVideoSid, BOOL bClipStart)
  512. {
  513. // DWORD dwWidth = _aviStreamsInfo[0]._aviStreamFormat._bitMapInfoHeader.lWidth;
  514. // DWORD dwHeight = _aviStreamsInfo[0]._aviStreamFormat._bitMapInfoHeader.lHeight;
  515. WORD wRoundedWidth, wRoundedHeight, wNumOfMB;
  516. DWORD dwFrameIncr, dwFixVal, dwFixFreq;
  517. WORD wAudStreamNum, wVidStreamNum,wSubStreamNum;
  518. WORD tempInputFps1;
  519.     DWORD fieldCounter;
  520. UINT16 tempOutputFps;
  521.     WORD audio_format,audio_block_align, audio_bitspersample;
  522.     UINT8 uiOffsetToClear;
  523. #ifdef K1_WL
  524. DEC_LL_DECODED_FRAME_RATE v_format;
  525. #endif
  526. BOOL bInternalSubtitleIsText;
  528. #if 0
  529. /* set the width of the picture for slot machine replacement */
  530. DEC_AVI_SetPicWidth(dwWidth);
  531. #endif
  532. /* Kill any existing Zoom */
  533. //DEC_SetZoomScale(NO_ZOOM);
  535. // <<< Robin_1011_2004_D
  536. tempInputFps1 = (_mpeg4VideoRate*100)/_mpeg4VideoScale;
  537. #ifdef PATCH_VIDEO_NOT_B
  538. bRequestPAL60 = FALSE;
  539. if ((gps->tv_standard == TV_SYS_PAL)  && (tempInputFps1>2550) && (FALSE == _bMPEG4IsBVopExist))
  540. {
  541. dbg_printf(("Video is 30f/s, No B-VOP, PAL TV output.n"));
  542. bRequestPAL60 = TRUE;
  543. }
  544. #endif
  545. // >>> Robin_1011_2004_D
  547. #ifdef SUPPORT_FLASH_CARD
  548. // if(IS_PLAYING_CARD)
  549. drv_abort_play();
  550. #endif
  552. // Clear the Share RAM
  553. for (uiOffsetToClear = 0; uiOffsetToClear < 16; uiOffsetToClear++)
  554. DEC_AVI_ClearSharedOffset(uiOffsetToClear); 
  556. /* Set DVP indication that this is a pause-stop (and not pure pause) */
  557. DEC_AVI_SetDemuxSharedBit(AVI_FILE_PAUSE_OFFSET, AVI_FILE_PAUSE_BIT);
  560. /* Configure the Decoder to the appropriate bitstream type */
  561. DEC_Stop_DVP_ADP_cmd((UINT8)0);
  563. #ifndef SUPPORT_FLASH_CARD
  564. drv_abort_play();
  565. #endif
  567. DEC_AVI_SetDivXVersion(_mpeg4VideoCodec);
  569. if (SI_IS_CURRENT_AVI_CLIP)
  570. DEC_SetDiskType(DEC_DISC_TYPE_AVI);
  571. #ifdef IS_ASF_CAPABLE
  572. else if (SI_IS_CURRENT_ASF_CLIP)
  573. DEC_SetDiskType(DEC_DISC_TYPE_ASF);
  574. #endif
  575. #ifdef IS_MP4_CAPABLE
  576. else if (SI_IS_CURRENT_MP4_CLIP)
  577. DEC_SetDiskType(DEC_DISC_TYPE_MP4);
  578. #endif
  580. DEC_prepare_to_decode();  /* Downloads the DVP AVI microcode */
  582. gns.clips.iClipSamplingRate = dwSamplingRate;
  584. gcst.mAudioStream = uiAudioSid;
  585. DEC_SetSID(DEC_SID_TYPE_AUDIO, uiAudioSIDDecoder);
  586. DEC_SetSID(DEC_SID_TYPE_VIDEO, uiVideoSid);
  588. PE_Clips_SelectClock(eCT_Decoder);
  590. /* Calculate the parameters to be sent to the DEMUX */
  591. wRoundedWidth = ((_mpeg4VideoWidth + 15) / 16) * 16;
  592. wRoundedHeight = ((_mpeg4VideoHeight + 15) / 16) * 16;
  594. if (wRoundedWidth == 512 && ((_mpeg4VideoCodec != DIVX_3_11) && (_mpeg4VideoCodec != MP43))) // Robin_1125_2004, MP43 is same as DivX311 
  595. {
  596. wNumOfMB = ((wRoundedWidth / 16) + 1) * (wRoundedHeight / 16);
  597. }
  598. else 
  599. {
  600. wNumOfMB = (wRoundedWidth / 16) * (wRoundedHeight / 16);
  601. }
  604. if (SI_IS_CURRENT_AVI_CLIP)
  605. {
  606. wVidStreamNum = ((_mpeg4VideoStreamID+ '0') << 8) | '0';
  607. if (0xFF == uiAudioSid)
  608. {
  609. wAudStreamNum = 0xFF; // Instruct the DEMUX to drop the audio chunks
  610. }
  611. else
  612. {
  613. wAudStreamNum = ((_mpeg4AudioStreamID + '0') << 8) | '0';
  614. }
  615. wSubStreamNum = ((_mpeg4SubtitleStreamID + '0') <<8) | '0';
  616. }
  617. else
  618. {
  619. wVidStreamNum = _mpeg4VideoStreamID;
  620. wAudStreamNum = _mpeg4AudioStreamID;
  621. wSubStreamNum = _mpeg4SubtitleStreamID;
  622. }
  623.     /* Frame Increment in 90KHZ */
  624. dwFrameIncr = (SCR_RATE*_mpeg4VideoScale)/(_mpeg4VideoRate);
  626.     /* Rate Fix Value , Rate Fix Freq => every Rate Fix 
  627.  * Freq (7 Frames) add Rate Fix Value to the TimeStamp 
  628.  */
  629. dwFixVal = (((SCR_RATE*_mpeg4VideoScale) - (dwFrameIncr * _mpeg4VideoRate))*100)/(_mpeg4VideoRate);
  631. dwFixFreq = 100;
  633. /* set the video output according to the movie (PAL/NTSC)
  634.  * mainlly used for Auto Mode
  635.  * I will call this function only for clear case of PAL/NTSC
  636.  */
  638. // <<< Robin_1011_2004_C
  639. if((tempInputFps1 > 2450 && tempInputFps1 < 2550) ||  wRoundedHeight > 480)
  640. {
  641. #ifdef K1_WL
  643. // DEC_LL_GetCodedVideoStandard(&v_format);
  644. // if ((DEC_LL_DECODED_FRAME_RATE_NTSC == v_format) && clr_tmp_string)
  645. //   hide_time();
  646. // clr_tmp_string = TRUE;
  647. #endif
  648. DEC_set_display_video_format(DEC_LL_DECODED_FRAME_RATE_PAL);  //TODO: change according to FPS of bitstream
  649. }
  650. else
  651. {
  652. #ifdef K1_WL
  653. // DEC_LL_GetCodedVideoStandard(&v_format);
  654. // if ((DEC_LL_DECODED_FRAME_RATE_PAL == v_format) && clr_tmp_string)
  655. //   hide_time();
  656. // clr_tmp_string = TRUE;
  657. #endif
  658. DEC_set_display_video_format(DEC_LL_DECODED_FRAME_RATE_NTSC);  //TODO: change according to FPS of bitstream
  659. }
  660. // >>> Robin_1011_2004_C
  664.    //FW0408_2005D Move from AVIClip_play() because it should be set before play
  665. // Set AVI video scaling
  666. DEC_EnableManualScaling(PROG_SCALER_MODE_CCRAM);
  667. DEC_SetViewMode(gps->view_mode);
  669. /* Set picture size */
  670. DEC_set_coded_video_size(_mpeg4VideoWidth, _mpeg4VideoHeight);
  672. /* Set TV display aspect ratio */
  673. DEC_set_Display_AspectRatio(gps->tv_shape);
  674. if ((TRUE == bClipStart) && (_mpeg4VideoStreamID != NO_STREAM))
  675. {
  676. #ifdef PATCH_DIVX_GARBAGE
  677. DEC_LL_BackgroundSwitch(DEC_LL_BG_SWITCH_BACKGROUND);
  678. #endif
  679. gcst.mNeedScaling = TRUE; //FW_0526_2005B Should set before DVP start. In Divx3.11 ucode, DVP send scaling info right after video task start.
  680. }
  682. /* Calculate how many frames the DVP should drop */
  683. if (gcst.actual_tv_std == DEC_LL_OUT_VIDEO_STANDARD_PAL)
  684. {
  685. tempOutputFps = 2500; /* PAL output, multiplied by 100 */
  686. dbg_printf(("PALn"));
  687. }
  688. else
  689. {
  690. tempOutputFps = 2997; /* NTSC output, multiplied by 100 */;
  691. dbg_printf(("NTSCn"));
  692. }
  694. if (tempOutputFps > tempInputFps1)
  695. {
  696. /* need to repeat field every X fields */
  697. tempOutputFps -= tempInputFps1;
  699. /* Round fieldCounter up */
  700. fieldCounter = (tempInputFps1+tempOutputFps-1)/tempOutputFps;
  701. //fieldCounter = tempInputFps1/tempOutputFps;
  702. }
  703. else
  704. {
  705. /* need to drop frame every X frames */
  706. fieldCounter = 0;
  707. }
  710. dbg_printf(("nFrame incr: %ld, Frame fix val: %ld, Frame fix freq: %ldn",
  711. dwFrameIncr, dwFixVal, dwFixFreq-1));
  713. dbg_printf(("fieldCounter: %dn",fieldCounter));
  715. // RB_TBD, need change DVP
  716. #if (defined(D_ENABLE_DIVX_WMA_SUPPORT) || defined(D_ENABLE_ADPCM_SUPPORT))
  717. if (PCM == _mpeg4AudioCodec)
  718. audio_format = PCM_AUDIO_SID;
  719. else if (ADPCM == _mpeg4AudioCodec)
  720. audio_format = ADPCM_MS_AUDIO_SID;
  721. else if (WMA == _mpeg4AudioCodec)
  722. audio_format = WMAV2_AUDIO_SID;
  723. else if (MP3 == _mpeg4AudioCodec)
  724. audio_format = MP3_AUDIO_SID;
  725. else
  726. audio_format = 0;
  727. #else
  728. audio_format = 0;
  729. #endif
  731. #ifdef D_ENABLE_ADPCM_SUPPORT
  732. if (ADPCM == _mpeg4AudioCodec || PCM == _mpeg4AudioCodec)
  733. audio_bitspersample = _mpeg4AudioBitsPerSample_ADPCM;
  734. else
  735. audio_bitspersample = 0;
  736. #else
  737. audio_bitspersample = 0;
  738. #endif
  740. #ifdef D_ENABLE_DIVX_WMA_SUPPORT
  741. if (ADPCM == _mpeg4AudioCodec)
  742. audio_block_align = _mpeg4AudioBlockAlign_ADPCM;
  743. else if (WMA == _mpeg4AudioCodec)
  744. audio_block_align = _mpeg4AudioBlockAlign_WMA;
  745. else
  746. audio_block_align = 0;
  747. #else
  748. audio_block_align = 0;
  749. #endif
  751. bInternalSubtitleIsText = SI_CLIPS_MP4_INTERNAL_SUBTITLE_ON;
  752. // Robin_0730_2004, set the VCB/ACB fullness limit when NEW_2X16M_MAPPING
  753. #ifdef NEW_2X16M_MAPPING
  754. {
  755. UINT16 uiACBStartAddressAVI, uiSPBStartAddressAVI, uiAPPStartAddressAVI;
  756. UINT16 uiVCBSize, uiACBSize, uiSPBSize;
  758. MPEG4Clip_dynamic_malloc(&uiACBStartAddressAVI, &uiSPBStartAddressAVI, &uiAPPStartAddressAVI);
  759. uiVCBSize = uiACBStartAddressAVI - OSD_BUFFER_SIZE_AVI;
  760. uiACBSize = uiSPBStartAddressAVI - uiACBStartAddressAVI;
  761. uiSPBSize = SPB_SIZE_AVI;
  763. _mpeg4InternalSubtitleBufferStartAddr = uiSPBStartAddressAVI;
  765. DEC_AVI_SetFileParams(_mpeg4VideoWidth, _mpeg4VideoHeight,
  766.   wRoundedWidth, wRoundedHeight, wNumOfMB,
  767.   dwFrameIncr,
  768.   dwFixVal, dwFixFreq-1, _bAVIDrmOn, wVidStreamNum, wAudStreamNum, wSubStreamNum,fieldCounter,
  769.   (uiVCBSize*13), (uiACBSize*13), (DWORD)(uiSPBSize*1024UL), 
  770.   audio_format,audio_block_align,audio_bitspersample, bInternalSubtitleIsText);
  771. }
  772. #else
  774. _mpeg4InternalSubtitleBufferStartAddr = (OSD_BUFFER_SIZE_AVI+VCB_SIZE_AVI+ACB_SIZE_AVI);
  775. DEC_AVI_SetFileParams(_mpeg4VideoWidth, _mpeg4VideoHeight,
  776.   wRoundedWidth, wRoundedHeight, wNumOfMB,
  777.   dwFrameIncr,
  778.   dwFixVal, dwFixFreq-1, _bAVIDrmOn, wVidStreamNum, wAudStreamNum, wSubStreamNum,fieldCounter,
  779.   (VCB_SIZE_AVI*13), (ACB_SIZE_AVI*13), (SPB_SIZE_AVI*1024UL), 
  780.   audio_format,audio_block_align,audio_bitspersample,bInternalSubtitleIsText);
  781. #endif
  782. /* Signal to the demux media type - CD/DVD */
  783. if (SI_IS_CURRENT_AVI_CLIP)
  784. DEC_Set_DVP_Gen_For_Clips_Disc_Type(DEC_DISC_TYPE_AVI);
  785. #ifdef IS_ASF_CAPABLE
  786. else if (SI_IS_CURRENT_ASF_CLIP)
  787. DEC_Set_DVP_Gen_For_Clips_Disc_Type(DEC_DISC_TYPE_ASF);
  788. #endif
  789. #ifdef IS_MP4_CAPABLE
  790. else if (SI_IS_CURRENT_MP4_CLIP)
  791. DEC_Set_DVP_Gen_For_Clips_Disc_Type(DEC_DISC_TYPE_MP4);
  792. #endif
  794. if (_mpeg4VideoStreamID != NO_STREAM)
  795. DEC_Set_DVP_GEN_For_MPEG4_Audio_Only(FALSE);
  796. else
  797. DEC_Set_DVP_GEN_For_MPEG4_Audio_Only(TRUE);
  799. DEC_PlaybackCommand(DEC_PLAYBACK_CMD_PLAY, NULL);
  801. DEC_AVI_SetMBInfoAddr();
  803. // Robin_0809_2004, transfer the video header data
  804. if (_mpeg4VideoHeaderDataLength > 0)
  805. {
  806. WORD wVideoHeaderSize;
  807. BYTE videoHeaderBuff[MPEG4_VIDEO_HEADER_CACHE_SIZE];
  808. WORD wVideoHeaderCacheSize;
  809. WORD wOffset = 0;
  810. wVideoHeaderSize = _mpeg4VideoHeaderDataLength; // multiple of 2 bytes
  811. while (wVideoHeaderSize > 0)
  812. {
  814. wVideoHeaderCacheSize = min(wVideoHeaderSize,MPEG4_VIDEO_HEADER_CACHE_SIZE);
  816. sc_GetBytes(SC_MPEG4_VIDEO_HEADER_DATA_ADDR,
  817.       wOffset,
  818.       wVideoHeaderCacheSize,
  819.       (BYTE*)&videoHeaderBuff
  820.      );
  822. wOffset += wVideoHeaderCacheSize;
  823. DEC_AVI_TransferVideoHeader(wVideoHeaderCacheSize/2,(WORD*)&videoHeaderBuff);
  824. wVideoHeaderSize -= wVideoHeaderCacheSize;
  825. }
  826. }
  828. /* SubPicture Reset */
  830. /* set the SP switch */
  831. outport(SPSWITCH_ADDR, 0x5);
  833. // Robin_1011_2004_C
  834. // outport(SPSCALE_ADDR, 0x0);
  837. // Robin_1011_2004_D
  838. #ifdef PATCH_VIDEO_NOT_B
  839. bRequestPAL60 = FALSE;
  840. #endif
  842.     // Set DVP indication that this is a pure pause
  843.     DEC_AVI_ClearDemuxSharedBit(AVI_FILE_PAUSE_OFFSET, AVI_FILE_PAUSE_BIT);
  845. }
  847. #if defined(SDRAM_2X16MBITS) && defined(NEW_2X16M_MAPPING)
  848. void MPEG4Clip_dynamic_malloc(UINT16* uiACBStartAddressAVI, UINT16* uiSPBStartAddressAVI, UINT16* uiAPPStartAddressAVI)
  849. {
  850. UINT16 uiINDEXStartAddressAVI;
  851. // UINT16 uiSUBTITLEStartAddressAVI;
  852. UINT16 uiACBSizeAVI;
  854. *uiAPPStartAddressAVI = (UINT16)(_dwMPEG4ProcessingEndAddr>>9); // 512 word
  856. if ((_mpeg4SubtitleStreamID != NO_STREAM) && (_mpeg4SubtitleType == INTERNAL_SUBP || _mpeg4SubtitleType == INTERNAL_SUBT)) // RB_TBD
  857. *uiSPBStartAddressAVI = *uiAPPStartAddressAVI -SPB_SIZE_AVI;
  858. else
  859. *uiSPBStartAddressAVI = *uiAPPStartAddressAVI;
  861. if(SI_IS_CURRENT_AVI_CLIP && (TRUE == _bAVIVideoBeforeAudio))
  862. {
  863. if (PCM == _mpeg4AudioCodec)
  864. uiACBSizeAVI = (*uiSPBStartAddressAVI - OSD_BUFFER_SIZE_AVI) / 2;
  865. else
  866. uiACBSizeAVI = (*uiSPBStartAddressAVI - OSD_BUFFER_SIZE_AVI) / 6;
  867. }
  868.    else if (PCM == _mpeg4AudioCodec)
  869. uiACBSizeAVI = 2 * (*uiSPBStartAddressAVI - OSD_BUFFER_SIZE_AVI) / 3;
  870. else
  871. uiACBSizeAVI = (*uiSPBStartAddressAVI - OSD_BUFFER_SIZE_AVI) / 3;
  873. if (uiACBSizeAVI < 150) // TBD..., need test
  874. uiACBSizeAVI = 150;
  876. *uiACBStartAddressAVI = *uiSPBStartAddressAVI - uiACBSizeAVI;
  878. #ifdef _DEBUG
  879. dbg_printf(("VCB start addresst: %d KBtVCB sizet: %d KBn", OSD_BUFFER_SIZE_AVI,*uiACBStartAddressAVI -OSD_BUFFER_SIZE_AVI ));
  880. dbg_printf(("ACB start addresst: %d KBtACB sizet: %d KBn", *uiACBStartAddressAVI,*uiSPBStartAddressAVI-*uiACBStartAddressAVI));
  881. dbg_printf(("SPB start addresst: %d KBtSPB sizet: %d KBn", *uiSPBStartAddressAVI,*uiAPPStartAddressAVI -*uiSPBStartAddressAVI ));
  882. // dbg_printf(("APP start addresst: %d KBtAPP sizet: %d KBn", *uiAPPStartAddressAVI, uiSUBTITLEStartAddressAVI -*uiAPPStartAddressAVI));
  883. // dbg_printf(("SUBTITLE start addresst: %d KBtSUBTITLE sizet: %d KBn", uiSUBTITLEStartAddressAVI,uiINDEXStartAddressAVI-uiSUBTITLEStartAddressAVI));
  884. #endif
  885. }
  886. #endif