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

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

DVD

开发平台：

Others

MP3.c：源码内容
  2. /****************************************************************************************
  3.  *  Copyright (c) 2000 ZORAN Corporation, All Rights Reserved
  4.  *  THIS IS UNPUBLISHED PROPRIETARY SOURCE CODE OF ZORAN CORPORATION
  5.  *
  6.  *  File: $Workfile: MP3.c $             
  7.  *
  8.  * Description:
  9.  * ============
  10.  * MP3 Clip implementation
  11.  *
  12.  * Log:
  13.  * ====
  14.  ****************************************************************************************
  15.  * Updates:
  16.  ****************************************************************************************
  17.  * $Log: /I76/I76_Common/I76_Reference/Playcore/Nav_Clips/MP3.c $
  18.  * 
  19.  ****************************************************************************************/
  21. #include "Config.h" // Global Configuration - do not remove!
  23. #ifdef _DEBUG
  24. #undef IFTRACE
  25. #define IFTRACE if (gTraceNavigator)
  26. #include "DebugDbgMain.h"
  27. #endif
  29. #include "DecoderDecoder.h"
  30. #include "DecoderDec_defs.h"
  31. #include "Decoderlow_levelDEC_LL_Def.h"
  32. #include "Drivedrv_api.h"
  33. #include "Drivedrv_defs.h"
  34. #include "LogoLogo.h"
  35. #include "PlaycoreCoremainCoreGDef.h"
  36. #include "PlaycoreAuxCacheAuxCache.h"
  37. #include "PlaycoreFileSysFileSystem.h"
  38. #include "PlaycoreNav_ClipsMP3.h"
  39. #include "PlaycoreNav_ClipsClip_Impl.h"
  40. #include "PlaycoreNav_ClipsGenericClip.h"
  41. #include "PlaycoreNav_ClipsNav_Clips.h"
  42. #include "PlaycoreNav_ClipsPE_Clips.h"
  43. #include "PlaycoreNav_CDDAPE_CD.h"
  45. /////////////////////////////////////////////////////////////////////////////
  46. // General MP3
  47. /////////////////////////////////////////////////////////////////////////////
  49. #define m_frameBytes  gns.clips.globals.mp3Globals.m_frameBytes
  50. #define dwUsPerFrame  gns.clips.globals.mp3Globals.dwUsPerFrame
  51. #define aHeaderBuffer  gns.clips.globals.mp3Globals.aHeaderBuffer
  52. #define uiBuffNo  gns.clips.globals.mp3Globals.uiBuffNo
  53. #define dwClipStartAddrForHeadBuffer gns.clips.globals.mp3Globals.dwClipStartAddrForHeadBuffer
  54. #define m_pXingHeader  gns.clips.globals.mp3Globals.m_pXingHeader
  55. #define ucMP3PlayabckFinishedCounter gns.clips.globals.mp3Globals.ucMP3PlayabckFinishedCounter
  57. typedef struct
  58. {
  59.    int sync; /* 1 if valid sync */
  60.    int id;
  61.    int option;
  62.    int prot;
  63.    int br_index;
  64.    int sr_index;
  65.    int pad;
  66.    int private_bit;
  67.    int mode;
  68.    int mode_ext;
  69.    int cr;
  70.    int original;
  71.    int emphasis;
  72. } MPEG_HEAD;
  74. static CONST int mp_br_table[2][16] = 
  75. {
  76. {0, 8 , 16, 24, 32, 40, 48, 56 , 64 , 80 , 96 , 112, 128, 144, 160, 0},
  77. {0, 32, 48, 56, 64, 80, 96, 112, 128, 160, 192, 224, 256, 320, 384, 0}
  78. };
  80. static CONST int mp_sr20_table[2][4] = 
  81. {
  82. {441, 480, 320, -999}, 
  83. {882, 960, 640, -999}
  84. };
  86. static CONST int mp_br_tableL1[2][16] = 
  87. {
  88. {0, 32, 48, 56, 64 , 80 , 96 , 112, 128, 144, 160, 176, 192, 224, 256, 0}, /* mpeg2 */
  89. {0, 32, 64, 96, 128, 160, 192, 224, 256, 288, 320, 352, 384, 416, 448, 0}
  90. };
  92. static CONST int mp_br_tableL3[2][16] = 
  93. {
  94. {0, 8 , 16, 24, 32, 40, 48, 56, 64 , 80 , 96 , 112, 128, 144, 160, 0}, /* mpeg 2 */
  95. {0, 32, 40, 48, 56, 64, 80, 96, 112, 128, 160, 192, 224, 256, 320, 0}
  96. };
  98. static CONST DWORD sample_rate_table[8] =
  99. {
  100.     22050L, 24000L, 16000L, 1L, 44100L, 48000L, 32000L, 1L
  101. };
  103. static CONST int l[4] = {25, 3, 2, 1};
  105. static int head_info(DWORD offset, unsigned int n, MPEG_HEAD * h);
  107. static int head_info3(DWORD offset, unsigned int n, MPEG_HEAD *h, unsigned int *searchForward); 
  109. static int head_info2(DWORD offset, unsigned int n, MPEG_HEAD * h);
  111. static void GetBitstreamStats(DWORD dwClipStartAddr, int *piTotalSeconds);
  113. static BOOL GetHeadInfo(DWORD dwClipStartAddr, MPEG_HEAD * pm_sMpegHead, int *pm_frameBytes);
  115. static void InitHeaderBuff(BYTE * buff, DWORD dwClipStartAddr);
  117. static BYTE GetCharFromDisc(DWORD n);
  119. static BOOL GetXingHeader(XHEADDATA *X,  DWORD offset);
  121. ////////////////////////////////////////////////////////////////////////////
  122. // Forward Declarations of Virtual Methods
  124. BOOL MP3Clip_getExtendedInfo(const struct Clip_TAG *i_pThis, 
  125.  WORD i_pExtInfo_sc_handle);
  127. void MP3Clip_refresh(Clip *i_pThis);
  129. enClipStatus MP3_getStatus(const Clip *i_pThis);
  131. void MP3_scan(Clip *i_pThis, int iScanSpeed);
  133. void MP3_recordMarker(Clip *i_pThis, ClipMarker *o_pMarker);
  135. void MP3_pause(Clip *i_pThis, BOOL bEnable);
  137. BOOL MP3_play(Clip *i_pThis, const ClipMarker *i_pResumeMarker,
  138.   BOOL bCacheOnly);
  140. UINT16 MP3Clip_GetTime(Clip *i_pThis);
  142. /////////////////////////////////////////////////////////////////////////////
  143. // Constants and Enumerations
  145. #define MAX_FRAME_SIZE 1441L
  146. #define NUM_OF_SANITY_CHECK 3L
  147. #define INITIAL_FRAME_SIZE (MAX_FRAME_SIZE * NUM_OF_SANITY_CHECK)
  148. #define MAX_DECODING_RETRY 32
  149. #define TEMP_BUFF_SIZE 128
  150. #define FRAMES_FLAG 0x0001
  151. #define BYTES_FLAG 0x0002
  153. #define MPEG_FRAMES_TO_SAMPLE 80
  155. #define ID3_GENRE_COUNT 116
  156. #define ID3_GENRE_DEFAULT 255
  158. #ifdef EXINO2 // ZKR GL041804 : No need to delay fo finishing the playback.
  159. #define DEFAULT_MP3_PLAYBACK_FINISHED_COUNTER 0
  160. #else 
  161. #define DEFAULT_MP3_PLAYBACK_FINISHED_COUNTER 10
  162. #endif
  164. LPWSTR _str2wcs(LPCSTR pszSource, LPWSTR pszDest, unsigned int cbDestSize);
  166. /////////////////////////////////////////////////////////////////////////////
  167. // Globals and Singletons
  169. // Valid Extenions List
  170. BEGIN_CLIP_VALID_EXTENSIONS_MAP(MP3)
  171. CLIP_VALID_EXTENSIONS_ENTRY(L"MP3")
  172. CLIP_VALID_EXTENSIONS_ENTRY(L"MP2")
  173. END_CLIP_VALID_EXTENSIONS_MAP()
  175. // Constant Attributes
  176. DECLARE_CLIP_CONST_ATTR(MP3, 
  177. DECLARE_CLIP_VTABLE(MP3Clip_getExtendedInfo,
  178. MP3_play,
  179. MP3_pause,
  180. MP3_getStatus,
  181. GenericClip_abort,
  182. MP3_recordMarker,
  183. MP3Clip_refresh,
  184. MP3Clip_GetTime,
  185. GenericClip_digest,
  186. MP3_scan
  187. ),
  188. eClipType_MP3,
  189. DEC_ASID_MP3, 0xFF, DEC_DISC_TYPE_MP3,
  190. ( eCA_Markable | eCA_Scanable ),
  191. NULL
  192. )
  194. #ifdef MOTOROLA
  195. #define BE_DWORD(a) a
  196. #define BE_WORD(a) a
  197. #else
  198. #define BE_DWORD(a) (DWORD)((a << 24) | ((a & 0xFF00) << 8) | ((a & 0xFF0000L) >> 8) | ((a & 0xFF000000L) >> 24))
  199. #define BE_WORD(a) (WORD)((a << 8) | (a >> 8))
  200. #endif // MOTOROLA
  202. #if (defined(CLIPS_ACQUIRE_EXTENDED_INFO) && defined(CLIPS_MP3_EXTRACT_ID3V1_TAG))
  203. BOOL isFailedToReadMP3Head = FALSE;
  205. static CONST LPSTR g_pszEmptyField= "                              ";
  207. static CONST LPWSTR g_aMP3_ID3Genres[ID3_GENRE_COUNT+1] =
  208. { L"", L"Blues", L"Classic Rock", L"Country", L"Dance", L"Disco", L"Funk", L"Grunge", 
  209.   L"Hip-Hop", L"Jazz", L"Metal", L"New Age", L"Oldies", L"Other", L"Pop", L"R&B", 
  210.   L"Rap", L"Reggae", L"Rock", L"Techno", L"Industrial", L"Alternative", L"Ska", 
  211.   L"Death Metal", L"Pranks", L"Soundtrack", L"Euro-Techno", L"Ambient", 
  212.   L"Trip-Hop", L"Vocal", L"Jazz+Funk", L"Fusion", L"Trance", L"Classical", 
  213.   L"Instrumental", L"Acid", L"House", L"Game", L"Sound Clip", L"Gospel", L"Noise", 
  214.   L"Alt. Rock", L"Bass", L"Soul", L"Punk", L"Space", L"Meditative", L"Instrumental Pop",
  215.   L"Instrumental Rock", L"Ethnic", L"Gothic", L"Darkwave", L"Techno-Industrial", 
  216.   L"Electronic", L"Pop-Folk", L"Eurodance", L"Dream", L"Southern Rock", L"Comedy", 
  217.   L"Cult", L"Gangsta", L"Top 40", L"Christian Rap", L"Pop/Funk", L"Jungle", 
  218.   L"Native American", L"Cabaret", L"New Wave", L"Psychadelic", L"Rave", 
  219.   L"Showtunes", L"Trailer", L"Lo-Fi", L"Tribal", L"Acid Punk", L"Acid Jazz", 
  220.   L"Polka", L"Retro", L"Musical", L"Rock & Roll", L"Hard Rock", L"Folk", 
  221.   L"Folk/Rock", L"National Folk", L"Swing", L"Fast-Fusion", L"Bebob", L"Latin", L"Revival", 
  222.   L"Celtic", L"Bluegrass", L"Avantgarde", L"Gothic Rock", L"Progressive Rock", 
  223.   L"Psychadelic Rock", L"Symphonic Rock", L"Slow Rock", L"Big Band", L"Chorus", 
  224.   L"Easy Listening", L"Acoustic", L"Humour", L"Speech", L"Chanson", L"Opera", 
  225.   L"Chamber Music", L"Sonata", L"Symphony", L"Booty Bass", L"Primus", 
  226.   L"Porn Groove", L"Satire", L"Slow Jam", L"Club", L"Tango", L"Samba", L"Folklore"
  227. };
  230. // The Frame Bitrate according to the MPEG-Layer (MPEG Audio 1.0, Section 2.4.2.3)
  231. static CONST UINT16 g_aBitrateByMpeg1Layer[15][3] = 
  232. {
  233. { 0  , 0  , 0   },
  234. { 32 , 32 , 32  },
  235. { 64 , 48 , 40  },
  236. { 96 , 56 , 48  },
  237. { 128, 64 , 56  },
  238. { 160, 80 , 64  },
  239. { 192, 96 , 80  },
  240. { 224, 112, 96  },
  241. { 256, 128, 112 },
  242. { 288, 160, 128 },
  243. { 320, 192, 160 },
  244. { 352, 224, 192 },
  245. { 384, 256, 224 },
  246. { 416, 320, 256 },
  247. { 448, 384, 320 }
  248. };
  250. static CONST UINT16 g_aBitrateByMpeg2Layer[15][3] = 
  251. {
  252. { 0  , 0  , 0   },
  253. { 32 , 32 , 8   },
  254. { 64 , 48 , 16  },
  255. { 96 , 56 , 24  },
  256. { 128, 64 , 32  },
  257. { 160, 80 , 64  },
  258. { 192, 96 , 80  },
  259. { 224, 112, 56  },
  260. { 256, 128, 64  },
  261. { 288, 160, 128 },
  262. { 320, 192, 160 },
  263. { 352, 224, 112 },
  264. { 384, 256, 128 },
  265. { 416, 320, 256 },
  266. { 448, 384, 320 }
  267. };
  269. #endif //(CLIPS_ACQUIRE_EXTENDED_INFO) && (CLIPS_MP3_EXTRACT_ID3V1_TAG)
  272. /////////////////////////////////////////////////////////////////////////////
  273. // Private Services
  275. #pragma argsused
  276. void MP3_setPresentationTime(UINT8 uPresentationTime)
  277. {
  278. dbg_printf(("WARNING: MP3_setPresentationTime() Failed: MP3 Clips cannot have a presentation time.n"));
  279. }
  282. #if (defined(CLIPS_ACQUIRE_EXTENDED_INFO) && defined(CLIPS_MP3_EXTRACT_ID3V1_TAG))
  284. BOOL MP3_getID3v1Tag(DWORD dwClipStartAddr, DWORD cbClipSize, 
  285.  WORD i_pExtInfo_sc_handle)
  286. {
  287. INT32 iOffset;
  288. BYTE aTagBuffer[ID3V1_SIZE];
  289. UINT16 uBlocksCnt;
  290. DWORD dwStartLBA;
  291. //Angie_0810_2004:Move the MP3 and WMA extend info from gns to SCPAD for I86 memory reducing.
  292. MP3_ID3v1Tag o_pID3v1Tag;
  294. // Reset the result
  295. memset(&o_pID3v1Tag, 0, sizeof(MP3_ID3v1Tag));
  296. o_pID3v1Tag.pszGenre= g_aMP3_ID3Genres[0];
  298. // First of all, calculate the LBA to fetch, and the offset within that LBA
  299. // in which the ID3v1-Tag should reside (the last 128 Bytes of the Clip).
  300. uBlocksCnt= (UINT16)(cbClipSize / LOGICAL_BLOCK_SIZE);
  301. dwStartLBA= (dwClipStartAddr + uBlocksCnt);
  302. iOffset= (cbClipSize - (LOGICAL_BLOCK_SIZE * (ULONG)uBlocksCnt) - ID3V1_SIZE);
  304. if (iOffset < 0) 
  305. {
  306. UINT32 uPortionOfLastSector= (cbClipSize - (LOGICAL_BLOCK_SIZE * (ULONG)uBlocksCnt));
  308. iOffset= (LOGICAL_BLOCK_SIZE - (ID3V1_SIZE - uPortionOfLastSector));
  310. dwStartLBA--;
  311. }
  313. // Now fetch the last 128 Bytes of the Clip
  314. if (! AuxCache_GetBytes(dwStartLBA, (DWORD)iOffset, ID3V1_SIZE, aTagBuffer)) 
  315. {
  316. dbg_printf(("Failed to extract an MP3-ID3v1 Tag.n"));
  317. isFailedToReadMP3Head = TRUE;
  318. drv_abort_play();
  319. return FALSE;
  320. }
  322. // Examine the Buffer, and search for the "TAG" identifier
  323. if (0 != strncmp((LPCSTR)aTagBuffer, "TAG", 3)) 
  324. {
  325. // The Clip doesn't have an ID3v1 Tag
  326. return FALSE;
  327. }
  329. // Copy the various fields into the destination Tag, converted into UNICODE-CS0
  330. if (0 != memcmp((LPCSTR)&aTagBuffer[3], g_pszEmptyField, ID3V1_TEXT_LENGTH));
  331. _str2wcs((LPCSTR)&aTagBuffer[3], o_pID3v1Tag.szSongName, sizeof(o_pID3v1Tag.szSongName));
  333. if (0 != memcmp((LPCSTR)&aTagBuffer[33], g_pszEmptyField, ID3V1_TEXT_LENGTH))
  334. _str2wcs((LPCSTR)&aTagBuffer[33], o_pID3v1Tag.szArtist, sizeof(o_pID3v1Tag.szArtist));
  336. if (0 != memcmp((LPCSTR)&aTagBuffer[63], g_pszEmptyField, ID3V1_TEXT_LENGTH))
  337. _str2wcs((LPCSTR)&aTagBuffer[63], o_pID3v1Tag.szAlbum, sizeof(o_pID3v1Tag.szAlbum));
  339. if (0 != memcmp((LPCSTR)&aTagBuffer[93], g_pszEmptyField, 4))
  340. _str2wcs((LPCSTR)&aTagBuffer[93], o_pID3v1Tag.szYear, sizeof(o_pID3v1Tag.szYear));
  342. if (0 != memcmp((LPCSTR)&aTagBuffer[97], g_pszEmptyField, ID3V1_TEXT_LENGTH))
  343. _str2wcs((LPCSTR)&aTagBuffer[97], o_pID3v1Tag.szComment, sizeof(o_pID3v1Tag.szComment));
  345. // Extrapulate the Track-Number field: if the Comment field's next-to-last char
  346. // is NULL, then the last char is the Track-Number.
  347. if (0 == o_pID3v1Tag.szComment[ID3V1_TEXT_LENGTH-2])
  348. o_pID3v1Tag.uTrackNum= o_pID3v1Tag.szComment[ID3V1_TEXT_LENGTH-1];
  349. else
  350. o_pID3v1Tag.uTrackNum= 0;
  352. // Assign the Genre-name
  353. if ((ID3_GENRE_DEFAULT == aTagBuffer[127]) || (ID3_GENRE_COUNT <= aTagBuffer[127]))
  354. o_pID3v1Tag.pszGenre= g_aMP3_ID3Genres[0]; // The Default Genre, or an Undefined one
  355. else
  356. o_pID3v1Tag.pszGenre= g_aMP3_ID3Genres[aTagBuffer[127] + 1];
  358. sc_SetBytes(i_pExtInfo_sc_handle,0,sizeof(MP3_ID3v1Tag),(BYTE *)&o_pID3v1Tag);
  360. drv_abort_play();
  362. return TRUE;
  363. }
  365. #endif //(CLIPS_ACQUIRE_EXTENDED_INFO) && (CLIPS_MP3_EXTRACT_ID3V1_TAG)
  367. /////////////////////////////////////////////////////////////////////////////
  368. // Public Services
  370. BOOL MP3Clip_isKindOf(LPCWSTR i_pszFilename)
  371. {
  372. return GenericClip_isKindOf(i_pszFilename, CLIP_VALID_EXTENSIONS(MP3));
  373. }
  376. void MP3Clip_construct(Clip *o_pThis, const FindData *i_pFileInfo)
  377. {
  378. GenericClip_construct(o_pThis, i_pFileInfo);
  380. o_pThis->m_pConstAttr= &CLIP_CONST_ATTR(MP3);
  381. }
  384. /////////////////////////////////////////////////////////////////////////////
  385. // Virtual Methods
  387. BOOL MP3Clip_getExtendedInfo(const struct Clip_TAG *i_pThis, 
  388.  WORD i_pExtInfo_sc_handle)
  389. {
  390. BOOL bSuccess= FALSE;
  391. int iTotalSeconds;
  393. dbg_printf(("MP3Clip_getExtendedInfo()n"));
  395. #ifdef CLIPS_MP3_EXTRACT_ID3V1_TAG
  396. ASSERT(NULL != i_pExtInfo_sc_handle)
  398. bSuccess= MP3_getID3v1Tag(i_pThis->m_cfiInfo.dwFileLocation, 
  399.   i_pThis->m_cfiInfo.cbFileSize,
  400.   i_pExtInfo_sc_handle);
  401. #endif //CLIPS_MP3_EXTRACT_ID3V1_TAG
  404. GetBitstreamStats(i_pThis->m_cfiInfo.dwFileLocation, &iTotalSeconds);
  406. gns.clips.uTotalPlaybackTime = iTotalSeconds;
  408. return bSuccess;
  409. }
  412. #pragma argsused
  413. void MP3Clip_refresh(Clip *i_pThis)
  414. {
  415. UINT32 dwBufferLevel;
  417. if (PST_PLAY == gcs.pstate) 
  418. {
  419. BOOL bEnableClock;
  421. dwBufferLevel = DEC_ReadCodeBufferFullness(DEC_AUDIO_CODE_BUFFER, DEC_FULLNESS_IN_BYTES);
  423. if (dwBufferLevel == 0)
  424. {
  425. bEnableClock = FALSE;
  426. }
  427. else
  428. {
  429. bEnableClock = TRUE;
  430. }
  432. if ( (0 == dwBufferLevel) && drv_is_play_done())
  433. {
  434. PE_Clips_EnableClock(bEnableClock, TRUE, 0);
  435. }
  436. else
  437. {
  438. PE_Clips_EnableClock(bEnableClock, FALSE, 0);
  439. }
  440. }
  441. else
  442. {
  443. if ( (PST_SCAN == gcs.pstate)  && (eCS_Finished == MP3_getStatus(i_pThis)) )
  444. {
  445. PE_Clips_EnableClock(FALSE, TRUE, 0);
  446. }
  447. }
  448. }
  450. enClipStatus MP3_getStatus(const Clip *i_pThis)
  451. {
  452. static UINT16 uiWatchDog = 100; // 10s, called on 100ms tick.
  453. static UINT16 uLastReadTime;
  455. if (PST_PLAY == gcs.pstate)
  456. {
  457. if (PE_Clips_GetClock() == uLastReadTime)
  458. {
  459. // either decoder got stuck or drive is trying to bring data.
  460. uiWatchDog--;
  461. }
  462. else
  463. {
  464. uiWatchDog = 100;
  465. uLastReadTime = PE_Clips_GetClock();
  466. }
  468. if (0 == uiWatchDog)
  469. {
  470. uiWatchDog = 100;
  471. return eCS_Finished;
  472. }
  473. }
  474. else
  475. {
  476. uiWatchDog = 100;
  477. }
  479. if (PST_SCAN != gcs.pstate)
  480. {
  481. if (drv_is_play_done() && DEC_IsPlaybackFinished(FALSE)) 
  482. {
  483. if (0 == ucMP3PlayabckFinishedCounter)
  484. {
  485. return eCS_Finished;
  486. }
  487. else
  488. {
  489. ucMP3PlayabckFinishedCounter--;
  490. return eCS_Busy;
  491. }
  492. }
  493.   
  494. ucMP3PlayabckFinishedCounter = DEFAULT_MP3_PLAYBACK_FINISHED_COUNTER;
  496. return eCS_Busy;
  497. }
  498. else
  499. {
  500. UINT16 uCurrTime = PE_Clips_GetClock();
  502. // Check if Scan in current Clip is finished
  503. if ( (uCurrTime >= gns.clips.uTotalPlaybackTime) ||
  504.         (0 == uCurrTime) )
  505. {
  506. return eCS_Finished;
  507. }
  508. else
  509. {
  510. return eCS_Busy;
  511. }
  512. }
  513. }
  515. void MP3_pause(Clip *i_pThis, BOOL bEnable)
  516. {
  517. if ( (PST_SCAN == gcs.pstate) || (0 != gns.clips.iScanSpeed) )
  518. {
  519. if (bEnable)
  520. {
  521. PE_Clips_EnableClock(FALSE, FALSE, 0);
  522. }
  523. else
  524. {
  525. if (PST_PLAY == gcs.pstate)
  526. {
  527. gns.clips.iScanSpeed = 0;
  528. }
  530. MP3_scan(i_pThis, gns.clips.iScanSpeed);
  531. }
  532. }
  533. else
  534. {
  535. GenericClip_pause(i_pThis, bEnable);
  536. }
  537. }
  539. BOOL MP3_play(Clip *i_pThis, const ClipMarker *i_pResumeMarker,
  540.   BOOL bCacheOnly)
  541. {
  542. DWORD dwStartLBA;
  543. ULONG ulBlocksCnt, cbPlaybackLength;
  545. dbg_printf(("MP3_play()n"));
  547. ucMP3PlayabckFinishedCounter = DEFAULT_MP3_PLAYBACK_FINISHED_COUNTER;
  549. // Cached-playback is unsupported by default
  550. if (bCacheOnly)
  551. return FALSE;
  553. drv_abort_play();
  555. // Kill any existing Zoom
  556. DEC_SetZoomScale(NO_ZOOM);
  558. // Configure the Decoder to the appropriate Bitstream Type
  559. DEC_SetDiskType((i_pThis->m_pConstAttr)->m_eBitstreamType);
  561. // Prepare for decoding
  562. DEC_prepare_to_decode();
  564. #ifdef CLIPS_MP3_EXTRACT_ID3V1_TAG
  565. if (gns.clips.cieCurrClip.mpeginfo.uLayer == IS_LAYER_II)
  566. {
  567. DEC_SetSID(DEC_SID_TYPE_AUDIO, MPEG_SID0);
  568. }
  569. else
  570. #endif
  571. {
  572. DEC_SetSID(DEC_SID_TYPE_AUDIO, MP3_SID);
  573. }
  575. DEC_SetSID(DEC_SID_TYPE_VIDEO, (i_pThis->m_pConstAttr)->m_eVideoSID);
  577.     // Set audio ID for MP2 again.
  578. #ifdef CLIPS_MP3_EXTRACT_ID3V1_TAG
  579. if (gns.clips.cieCurrClip.mpeginfo.uLayer == IS_LAYER_II)
  580. {
  581. DEC_SetSID(DEC_SID_TYPE_AUDIO, MPEG_SID0);
  582. }
  583. #endif
  584. // Select the appropriate Clock
  585. PE_Clips_SelectClock(eCT_Internal);
  587. // Calculate the Playback Start-Address
  588. if (NULL == i_pResumeMarker) 
  589. {
  590. // Start at the beginning
  591. dwStartLBA= (i_pThis->m_cfiInfo).dwFileLocation;
  593. }
  594. else 
  595. {
  596. // Playback is being resumed
  597. dwStartLBA= i_pResumeMarker->dwAddress;
  598. }
  600. // Calculate the Playback Length (in Bytes)
  601. cbPlaybackLength= ( (i_pThis->m_cfiInfo).cbFileSize - 
  602. (LOGICAL_BLOCK_SIZE * (dwStartLBA - (i_pThis->m_cfiInfo).dwFileLocation)) );
  604. ulBlocksCnt= ((cbPlaybackLength + LOGICAL_BLOCK_SIZE - 1) / LOGICAL_BLOCK_SIZE);
  606. // Inform the Decoder of the Playback-Range
  607. PE_Clips_SetPlaybackRange(dwStartLBA, ulBlocksCnt, cbPlaybackLength/2);
  609. // Invoke playback of the Decoder & Drive
  610. // NOTE: The order of invocation is important, and must not be changed!
  611. DEC_PlaybackCommand(DEC_PLAYBACK_CMD_PLAY, NULL);
  613. if (!PE_Clips_Playback_Sectors(DRVCF_CDSPEED_1X | DRVF_PLAY_CD_AV_DATA, dwStartLBA, ulBlocksCnt))
  614. {
  615. tr_printf(("WARNING: MP3_play() Failed [1]n"));
  616. return FALSE;
  617. }
  619. // Restart the Clock
  620. PE_Clips_EnableClock(TRUE, TRUE,
  621.  (NULL != i_pResumeMarker) ? i_pResumeMarker->uTime : 0);
  623. return TRUE;
  624. }
  626. void MP3_scan(Clip *i_pThis, int iScanSpeed)
  627. {
  628. UINT16 ulCurrTime = PE_Clips_GetClock();
  630. dbg_printf(("MP3 Scan(%d)n", iScanSpeed));
  632. if (iScanSpeed != 0)
  633. {
  634. if (0 < iScanSpeed && 0 == ulCurrTime)
  635. {
  636. ulCurrTime = 1;
  637. }
  639. PE_Clips_SelectClock(eCT_Internal);
  640. PE_Clips_EnableClock(TRUE, TRUE, ulCurrTime); // Reset curent clock
  642. if (PST_PLAY == gcs.pstate)
  643. {
  644. PE_CD_AbortPlayback(TRUE);
  645. } 
  646. gcs.pstate = PST_SCAN;
  647. gns.clips.iScanSpeed = iScanSpeed;
  648. }
  649. else
  650. {
  651. ClipMarker mClipMarker;
  652. PE_Clips_SelectClock(eCT_Decoder);
  654. // Cancel Scan during Scan mode
  655. mClipMarker.dwAddress = MP3_Time_To_Address(ulCurrTime);
  656. mClipMarker.uTime = ulCurrTime;
  657. gns.clips.iScanSpeed = 0;
  658. gcs.pstate = PST_PLAY;
  659. dbg_printf(("Resume from %lx, file start address is %lxn", mClipMarker.dwAddress, i_pThis->m_cfiInfo.dwFileLocation));
  660. (i_pThis->m_pConstAttr->m_vtable.m_pfPlay)(i_pThis, &mClipMarker, FALSE);
  661. }
  662. return;
  663. }
  665. void MP3_recordMarker(Clip *i_pThis, ClipMarker *o_pMarker)
  666. {
  667. if (NULL != o_pMarker) 
  668. {
  669. DWORD dwStartAddress, dwJumpOffset;
  670. UINT16 uiTime;
  672. // Record the current position
  673. uiTime = PE_Clips_GetClock();
  675. o_pMarker->uTime = uiTime;
  677. dwStartAddress = MP3_Time_To_Address(uiTime); 
  679. o_pMarker->dwAddress = dwStartAddress;
  681. o_pMarker->uClipNumer = gns.clips.uCurrentClipNumber;
  682. }
  684. return;
  685. }
  687. UINT16 MP3Clip_GetTime(Clip *i_pThis)
  688. {
  689. UINT16 iCurrentTime;
  691. // Update Current Elapsed Time
  692. iCurrentTime = PE_Clips_GetClock();
  694. return iCurrentTime;
  695. }
  697. DWORD MP3_Time_To_Address(WORD uTime)
  698. {
  699. DWORD dwJumpOffset;
  701. if (dwUsPerFrame)
  702. {
  703. dwJumpOffset = ((DWORD)(uTime)*1000000/dwUsPerFrame *m_frameBytes)>>11;
  704. }
  705. else
  706. {
  707. dwJumpOffset = 0;
  708. }
  710. return (gns.clips.cieCurrClip.ciInfo.dwFileLocation) + dwJumpOffset;
  712. }
  714. /*--------------------------------------------------------------*/
  715. static int head_info(DWORD offset, unsigned int n, MPEG_HEAD * h)
  716. {
  717. int framebytes;
  718. int mpeg25_flag;
  720. if (n > 10000)
  721. n = 10000; /* limit scan for free format */
  725. h->sync = 0;
  726. //if ((GetCharFromDisc(0] == 0xFF) && ((GetCharFromDisc(1] & 0xF0) == 0xF0))
  727. if ((GetCharFromDisc(offset + 0) == 0xFF) && ((GetCharFromDisc(offset +0+1) & 0xF0) == 0xF0))
  728. {
  729. mpeg25_flag = 0; // mpeg 1 & 2
  731. }
  732. else if ((GetCharFromDisc(offset +0) == 0xFF) && ((GetCharFromDisc(offset +0+1) & 0xF0) == 0xE0))
  733. {
  734. mpeg25_flag = 1; // mpeg 2.5
  736. }
  737. else
  738. return 0; // sync fail
  740. h->sync = 1;
  741. if (mpeg25_flag)
  742. h->sync = 2; //low bit clear signals mpeg25 (as in 0xFFE)
  744. h->id = (GetCharFromDisc(offset +0+1) & 0x08) >> 3;
  745. h->option = (GetCharFromDisc(offset +0+1) & 0x06) >> 1;
  746. h->prot = (GetCharFromDisc(offset +0+1) & 0x01);
  748. h->br_index = (GetCharFromDisc(offset +0+2) & 0xf0) >> 4;
  749. h->sr_index = (GetCharFromDisc(offset +0+2) & 0x0c) >> 2;
  750. h->pad = (GetCharFromDisc(offset +0+2) & 0x02) >> 1;
  751. h->private_bit = (GetCharFromDisc(offset +0+2) & 0x01);
  752. h->mode = (GetCharFromDisc(offset +0+3) & 0xc0) >> 6;
  753. h->mode_ext = (GetCharFromDisc(offset +0+3) & 0x30) >> 4;
  754. h->cr = (GetCharFromDisc(offset +0+3) & 0x08) >> 3;
  755. h->original = (GetCharFromDisc(offset +0+3) & 0x04) >> 2;
  756. h->emphasis = (GetCharFromDisc(offset +0+3) & 0x03);
  759. // if( mpeg25_flag ) {
  760.  //    if( h->sr_index == 2 ) return 0;   // fail 8khz
  761.  //}
  764. /* compute framebytes for Layer I, II, III */
  765. if (h->option < 1)
  766. return 0;
  767. if (h->option > 3)
  768. return 0;
  770. framebytes = 0;
  772. #ifdef CLIPS_MP3_EXTRACT_ID3V1_TAG
  773. if (h->br_index > 0)
  774. {
  775. if (h->option == 3)
  776. { /* layer I */
  777. gns.clips.cieCurrClip.mpeginfo.uLayer = 1;
  778. framebytes =
  779. (ULONG)240 * mp_br_tableL1[h->id][h->br_index]
  780. / mp_sr20_table[h->id][h->sr_index];
  781. framebytes = 4 * framebytes;
  782. }
  783. else if (h->option == 2)
  784. { /* layer II */
  785. gns.clips.cieCurrClip.mpeginfo.uLayer = 2;
  786. framebytes =
  787. (ULONG)2880 * mp_br_table[h->id][h->br_index]
  788. / mp_sr20_table[h->id][h->sr_index];
  789. }
  790. else if (h->option == 1)
  791. { /* layer III */
  792. gns.clips.cieCurrClip.mpeginfo.uLayer = 3;
  793. if (h->id)
  794. { // mpeg1
  796. framebytes =
  797. (ULONG)2880 * mp_br_tableL3[h->id][h->br_index]
  798. / mp_sr20_table[h->id][h->sr_index];
  799. }
  800. else
  801. { // mpeg2
  803. if (mpeg25_flag)
  804. { // mpeg2.2
  806. framebytes =
  807. (ULONG)2880 * mp_br_tableL3[h->id][h->br_index]
  808. / mp_sr20_table[h->id][h->sr_index];
  809. }
  810. else
  811. {
  812. framebytes =
  813. (ULONG)1440 * mp_br_tableL3[h->id][h->br_index]
  814. / mp_sr20_table[h->id][h->sr_index];
  815. }
  816. }
  817. }
  818. }
  819. else
  820.       framebytes = -1; /* free format */
  821. #endif
  823. return framebytes;
  824. }
  826. static int head_info3(DWORD offset, unsigned int n, MPEG_HEAD *h, unsigned int *searchForward) {
  827. unsigned int pBuf = 0;
  828.    BYTE c0,c1;
  830.    c0 = GetCharFromDisc(offset + pBuf);
  831.    c1 = GetCharFromDisc(offset + pBuf+1);
  832. // jdw insertion...
  833.    while ((pBuf < n) && !((c0 == 0xFF) &&
  834.           ((c1 & 0xF0) == 0xF0 ||
  835.           (c1 & 0xF0) == 0xE0)))
  836.    {
  837. pBuf++;
  838. c0 = GetCharFromDisc(offset + pBuf);
  839. c1 = GetCharFromDisc(offset + pBuf+1);
  840.    }
  842.    if (pBuf == n) return 0;
  844.    *searchForward = pBuf;
  845.    return head_info2(offset + pBuf, n - pBuf,h);
  847. }
  849. /*--------------------------------------------------------------*/
  850. static int head_info2(DWORD offset, unsigned int n, MPEG_HEAD * h)
  851. {
  852. int framebytes;
  854. framebytes = head_info(offset, n, h);
  856. if (framebytes == 0)
  857. return 0;
  859. return framebytes;
  860. }
  862. static void GetBitstreamStats(DWORD dwClipStartAddr, int *piTotalSeconds)
  863. {
  864. int sampRateIndex;
  865. MPEG_HEAD m_sMpegHead;
  866. DWORD dwTotalFrames, dwSampleRate;
  867. int iLayer;
  868. //<<Leon.He_1001_05: Prevent the total time caculating overflow
  869. DWORD dwTempTotalFrames;
  870. WORD wShift = 0;
  871. //>>Leon.He_1001_05
  873. *piTotalSeconds = 0;
  874. dwUsPerFrame = 0;
  875. dwTotalFrames = dwSampleRate = 0;
  877. if (FALSE == GetHeadInfo(dwClipStartAddr, &m_sMpegHead, &m_frameBytes))
  878. {
  879. dwTotalFrames = -1;
  880. *piTotalSeconds = -1;
  881. return;
  882. }
  884. sampRateIndex = 4 * m_sMpegHead.id + m_sMpegHead.sr_index;
  885. dwSampleRate = sample_rate_table[sampRateIndex];
  887. if ((m_sMpegHead.sync & 1) == 0)
  888. dwSampleRate = dwSampleRate / 2;    // mpeg25
  889. gns.clips.iClipSamplingRate = dwSampleRate;
  890. iLayer = l[m_sMpegHead.option];
  892. if (m_sMpegHead.id == 1)
  893. dwUsPerFrame = (ULONG)(1152 * 1000000) / (ULONG)dwSampleRate;
  894. else
  895. dwUsPerFrame = (ULONG)(576 * 1000000) / (ULONG)dwSampleRate;
  897. #ifdef CLIPS_MP3_EXTRACT_ID3V1_TAG
  898. if (gns.clips.cieCurrClip.ciInfo.cbFileSize > 0 && 0 != m_frameBytes)
  899. {
  901. //<<Leon.He_1001_05: Prevent the total time caculating overflow
  902. // MP3 VBR total time
  903. if (gns.clips.cieCurrClip.mpeginfo.isXingHeaderOn)
  904. dwTotalFrames = m_pXingHeader.frames;
  905. else
  906. dwTotalFrames = gns.clips.cieCurrClip.ciInfo.cbFileSize / m_frameBytes;
  908. dwTempTotalFrames = dwTotalFrames;
  909. wShift = 0;
  910. while ((DWORD_MAX/dwUsPerFrame)< dwTempTotalFrames)
  911. {
  912. wShift++;
  913. dwTempTotalFrames = dwTotalFrames>>wShift;
  914. }
  915. *piTotalSeconds = ((ULONG) dwTempTotalFrames *
  916. (ULONG) dwUsPerFrame)/ (1000000>>wShift);
  917. //>>Leon.He_1001_05
  918. }
  919. else
  920. {
  921. dwTotalFrames = -1;
  922. *piTotalSeconds = -1;
  923. }
  924. #endif
  925. return ;
  926. }
  928. static void InitHeaderBuff(BYTE * buff, DWORD dwClipStartAddr)
  929. {
  930. aHeaderBuffer = buff;
  931. uiBuffNo = -1;
  932. dwClipStartAddrForHeadBuffer = dwClipStartAddr;
  933. }
  935. static BYTE GetCharFromDisc(DWORD n)
  936. {
  937. //LeonHe_2005_0519: Jump out directly when Failed to read the MP3 Head.
  938. if(isFailedToReadMP3Head)
  939. return NULL;
  940. if((n/TEMP_BUFF_SIZE) != uiBuffNo)
  941. {
  942. uiBuffNo = n/TEMP_BUFF_SIZE;
  943. //AngieHe_1111_2004: Add (DOWRD) to avoid the offset overflow.
  944. if (!AuxCache_GetBytes(dwClipStartAddrForHeadBuffer, (DWORD)uiBuffNo*TEMP_BUFF_SIZE, TEMP_BUFF_SIZE, aHeaderBuffer))
  945. {
  946. memset(aHeaderBuffer, 0, TEMP_BUFF_SIZE);
  947. //>>LeonHe_2005_0519: Set a Flag when Failed to read the MP3 Head.
  948. isFailedToReadMP3Head = TRUE;
  949. drv_abort_play();
  950. //<<LeonHe_2005_0519
  951. }
  952. }
  954. return (aHeaderBuffer[n%TEMP_BUFF_SIZE]);
  955. }
  958. static BOOL GetHeadInfo(DWORD dwClipStartAddr, MPEG_HEAD * pm_sMpegHead, int *pm_frameBytes)
  959. {
  960. int          iLoop, iFrame, iOffset;
  961. int          iLastSRIndex = -1, iLastOption = -1;
  962. int          iLastId = -1, iLastMode = -1;
  963. unsigned int iForward;
  964. BYTE  abTempBuffer[TEMP_BUFF_SIZE];
  965. MPEG_HEAD m_sMpegHead;
  967. #ifdef CLIPS_MP3_EXTRACT_ID3V1_TAG
  968. InitHeaderBuff(abTempBuffer, dwClipStartAddr);
  970. for (iLoop = 0; iLoop < MAX_DECODING_RETRY; iLoop++)
  971. {
  973. for(iFrame = 0, iOffset = 0; iFrame < NUM_OF_SANITY_CHECK; iFrame++)
  974. {
  975. m_frameBytes = head_info3((DWORD)iLoop*INITIAL_FRAME_SIZE + iOffset,INITIAL_FRAME_SIZE - iOffset, &m_sMpegHead,&iForward);
  977. if (m_frameBytes > 0 && iFrame == 0)
  978. {
  979. iOffset += m_frameBytes + iForward + m_sMpegHead.pad;
  980. iLastSRIndex = m_sMpegHead.sr_index;
  981. iLastOption = m_sMpegHead.option;
  982. iLastId = m_sMpegHead.id;
  983. iLastMode = m_sMpegHead.mode;
  984. continue;
  985. }
  987. if (m_frameBytes > 0 && m_frameBytes < MAX_FRAME_SIZE &&
  988. (m_sMpegHead.option == 1 || m_sMpegHead.option == 2) &&
  989. iLastSRIndex == m_sMpegHead.sr_index &&
  990. iLastOption == m_sMpegHead.option && 
  991. iLastId == m_sMpegHead.id && 
  992. iLastMode == m_sMpegHead.mode)
  993. {
  994. iOffset += m_frameBytes + iForward + m_sMpegHead.pad;
  995. iLastSRIndex = m_sMpegHead.sr_index;
  996. iLastOption = m_sMpegHead.option;
  997. iLastId = m_sMpegHead.id;
  998. iLastMode = m_sMpegHead.mode;
  1000. //<<<LeonH_0818_2003_A :For Get mp3 VBR total time
  1001. if (iFrame < NUM_OF_SANITY_CHECK - 1)
  1002. continue; 
  1003. if (gns.clips.cieCurrClip.mpeginfo.isXingHeaderOn)
  1004. gns.clips.cieCurrClip.mpeginfo.isXingHeaderOn = FALSE;
  1005. if (!GetXingHeader(&m_pXingHeader, 0))
  1006. gns.clips.cieCurrClip.mpeginfo.isXingHeaderOn = FALSE;
  1007. else
  1008. gns.clips.cieCurrClip.mpeginfo.isXingHeaderOn = TRUE;
  1009. //<<<Leonh_0818_2003_A
  1011. continue;
  1013. }
  1016. break;
  1017. }
  1018. if (iFrame == NUM_OF_SANITY_CHECK)
  1019. {
  1020. memcpy(pm_sMpegHead, &m_sMpegHead, sizeof(m_sMpegHead));
  1021. *pm_frameBytes = m_frameBytes;
  1022. return TRUE;
  1023. }
  1024. }
  1025. #endif
  1026. return FALSE;
  1027. }
  1029. //<<<LeonH_0818_2003_A :For Get mp3 VBR total time
  1030. int ExtractI4(DWORD offset)
  1031. {
  1032.     int x;
  1033.     // big endian extract
  1034.     
  1035.     x = GetCharFromDisc(offset++);
  1036.     x <<= 8;
  1037.     x |= GetCharFromDisc(offset++);
  1038.     x <<= 8;
  1039.     x |= GetCharFromDisc(offset++);
  1040.     x <<= 8;
  1041.     x |= GetCharFromDisc(offset);
  1042.     
  1043.     return x;
  1044. }
  1046. static BOOL GetXingHeader(XHEADDATA *X,  DWORD offset)
  1047. {
  1048. int i, head_flags;
  1049. int h_id, h_mode, h_sr_index;
  1051. // get Xing header data
  1052. X->flags = 0;     // clear to null incase fail
  1054. // get selected MPEG header data
  1055. h_id= (GetCharFromDisc(offset +0+1) & 0x08) >> 3;
  1056. h_mode = (GetCharFromDisc(offset +0+3) & 0xc0) >> 6;
  1058. // determine offset of header
  1059. if( h_id ) 
  1060. {        // mpeg1
  1061. if( h_mode != 3 ) 
  1062. offset+=(32+4);
  1063. else              
  1064. offset+=(17+4);
  1065. }
  1066. else 
  1067. {      // mpeg2
  1068. if( h_mode != 3 ) 
  1069. offset+=(17+4);
  1070. else            
  1071. offset+=(9+4);
  1072. }
  1073.      if(GetCharFromDisc(offset++) !='X') return FALSE;
  1074.      if(GetCharFromDisc(offset++) !='i') return FALSE;
  1075.      if(GetCharFromDisc(offset++) !='n') return FALSE;
  1076.      if(GetCharFromDisc(offset++) !='g') return FALSE;
  1077.     
  1078. X->h_id = h_id;
  1080. head_flags = X->flags = ExtractI4(offset); offset+=4;      // get flags
  1082. if( head_flags & FRAMES_FLAG ) {X->frames   = ExtractI4(offset); offset+=4;}
  1083. if( head_flags & BYTES_FLAG )  {X->bytes = ExtractI4(offset); offset+=4;}
  1084. return TRUE;       // success
  1085. }
  1086. //<<<Leonh_0818_2003_A