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

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

DVD

开发平台：

Others

Nav_sacd.c：源码内容
  1. /*
  2. file: nav_sacd.c
  3. desc: Implements event handler for SACD.
  4. Created on: Nov 7, 2003
  5. */
  7. #include "config.h"
  9. #if D_SUPPORT_SACD
  11. #ifdef _DEBUG
  12. #undef IFTARCE
  13. #define IFTRACE if (gTraceCore)
  14. #include "DebugDbgMain.h"
  15. #endif
  19. #include "IncludeSysDefs.h"
  20. #include "Kernelker_api.h"
  21. #include "KernelEventDef.h"
  22. #include "PlaycoreCoremaincoregdef.h"
  23. #include "Playcoreplaymodeplaymode.h"
  24. #include "Playcorenav_sacdpe_sacd.h"
  25. #include "Playcorescpadscmgr.h"
  26. #include "PlaycorescpadScPadAlloc.h"
  27. #include "Playcorenav_sacdsacd_uart.h"
  28. #include "PlaycoreSAMPsamp_gen.h"
  29. #include "PlaycoreSAMPsamp_nav.h"
  30. #include "PlaycoreSAMPsamp_apm.h"
  31. #include "PlaycoreSAMPsamp_sdm.h"
  33. #include "Playcorenav_sacdhweval_zoran.h"
  35. #include "Playcorenav_sacdnav_sacd.h"
  38. extern BOOL g_in_full_stop;
  42. static SAMP(ErrCode) Constructor(void);
  43. static void Destructor(void);
  44. static void SampCallback(SAMP(BitSet32) Event, void * EventData);
  45. static void NavCallback(SAMP(BitSet32) Event, void * EventData);
  46. #ifndef SACD_AREA_INFO_INSDRAM
  47. static void SaveSACDAreaInfo(SAMP(SAMP_AreaInfoDef) *stereo,SAMP(SAMP_AreaInfoDef) *multi);
  48. #endif
  50. /////////////////////////////////////////////////////////////////////////////////////////////////
  51. // int SACD_Navigator(HDLR_OP Op, EVENT Event, void *Param) -
  52. // The main router for SACD-Navigation Events.
  53. //
  54. // Input:
  55. // Op - The type of operation being invoked
  56. // Event - The event to route
  57. // Param - An optional parameter for the event being routed
  58. //
  59. // Output:
  60. // Zero if the routing is successful.
  62. int SACD_Navigator(HDLR_OP Op, EVENT Event, void *Param)
  63. {
  64.    SAMP(ErrCode) err = SAMP(ERR_OK);
  66. switch (Op)
  67. {
  68. case HDLR_ENTER: Constructor();
  69. //<<ZKR ML:033104 Aviod pop sound  when loading  sacd
  70. #ifdef EXINO2  
  71. DAC_SACD_SetMute(FALSE);
  72. #endif
  73. //>>ZKR ML:033104
  74. break;
  76. case HDLR_EXIT: Destructor();
  77. break;
  79. case HDLR_EVENT:
  80. switch (Event)
  81. {
  82. case IE_CORE_PAUSE:
  83. err = SAMP(NAV_Pause)();
  84. break;
  86. case IE_CORE_STOP:
  88.                         //todo: check how to do full stop.
  89.                         SAMP(NAV_Stop)();
  90.                g_in_full_stop = TRUE; /* forces next PLAY to be mapped to RESTART */
  91. // PE_SACD_AbortPlayback(0); //todo check later.
  93. break;
  95. case IE_CORE_PLAY:
  96.                         if(gcs.pstate == PST_PAUSE || gcs.pstate== PST_SCAN)
  97.                         {
  98.                          //only valid when it's pause or trick mode state.
  99.                          err = SAMP(NAV_ResumePlay)();
  100.  break;
  101.                         }
  103.                         //fall through
  105. case IE_CORE_RESTART:
  108.                         if(PM_IsPlaybackProgram(PM_GetPlaybackMode()))
  109. err = SAMP(NAV_PlayTrack)(SACD_GLOBALS.ProgramList.tracks[0], SACD_GLOBALS.gbPlayPauseArea? 0:1);
  110.                         else
  111.                         err = SAMP(NAV_PlayTrack)(1, SACD_GLOBALS.gbPlayPauseArea? 0:1);
  113.                         break;
  115. case IE_CORE_NEXT_CHAPTER:
  116. err = SAMP(NAV_NextTrack)();
  117. break;
  119. case IE_CORE_PREVIOUS_CHAPTER:
  120. err = SAMP(NAV_PreviousTrack)();
  121. break;
  123. case IE_CORE_GOTO_ENTRY:
  124. case IE_CORE_MENU_NUMERICAL_SELECTION:
  126.                         if(PM_IsPlaybackProgram(PM_GetPlaybackMode()))
  127.                         err = SAMP(NAV_PlayTrack)(SACD_GLOBALS.ProgramList.tracks[(int)Param], SACD_GLOBALS.gbPlayPauseArea? 0:1);
  128.                         else
  129.                         err = SAMP(NAV_PlayTrack)((int)Param, SACD_GLOBALS.gbPlayPauseArea? 0:1);
  130. break;
  132. case IE_CORE_AB_REPEAT:
  133. if (0 == (int)Param) {
  134.                            err = SAMP(NAV_RepeatAB)(SAMP(NAV_REPEAT_AB_OFF));
  135.      PM_SetRepeatAB(0);
  136. break;
  137. }
  139. if (PM_GetRepeatAB() & PM_REPEAT_AB_B) {
  140.                            err = SAMP(NAV_RepeatAB)(SAMP(NAV_REPEAT_AB_OFF));
  141.      PM_SetRepeatAB(0);
  142. }
  143. else { //after set A or A-B, set repeat single, then A will never be setted for the dwStartAddress is still there.
  144. if ((0 == PM_GetRepeatAB()))// && ((g_pCDDANav->m_PositionA).iPlaylistItem < 0))      // so I remove this condition, if this is necessary, let me know please, tonnyg
  145. {
  146.                             err = SAMP(NAV_RepeatAB)(SAMP(NAV_REPEAT_AB_A));
  147.  PM_SetRepeatAB(PM_REPEAT_AB_A);
  148. }
  149. else {
  150.                               err = SAMP(NAV_RepeatAB)(SAMP(NAV_REPEAT_AB_AB));
  151. PM_SetRepeatAB(PM_REPEAT_AB_B);
  152. }
  153. }
  155. break;
  157. #if 0 //SAMP doesn't support bookmark.
  158. case IE_CORE_SET_BOOKMARK:
  159. #ifdef HW_POWER_ON_RESUME
  160. NVM_BMK_SET((int)Param);
  161. #endif
  162. SetMarker(eBookmark, (WORD)Param - 1);
  163. break;
  165. case IE_CORE_GOTO_BOOKMARK:
  166. OnGoToBookmark((WORD)Param - 1);
  167. break;
  169. #endif
  171. case IE_CORE_SCAN:
  172.                        if(0 == (int)Param) //normal speed play
  173.                        {
  174.                         err = SAMP(NAV_ResumePlay)();
  175.                        }
  176.                        else
  177.                        if(0 < (int)Param) //fast forward
  178.                        {
  179.                         err = SAMP(NAV_ForwardScan)((SAMP(UInt8)) Param);
  180.                        }
  181.                        else
  182.                        if(0 > (int)Param) //fast backward
  183.                        {
  184.                         int param = -((int)Param);
  185.                         err = SAMP(NAV_BackwardScan)((SAMP(UInt8)) param);
  186.                        }
  187. break;
  189. case IE_CORE_TICK_ONE_SEC:
  190. break;
  192. case IE_CORE_TICK_200:
  193. // OnTick();
  194. break;
  197. case IE_CORE_SEAMLESS_MODE_CHANGE:
  199.                         //non_shuffle to shuffle
  200.                         if(PM_IsPlaybackShuffle(PM_GetPlaybackMode()))
  201.                          err = SAMP(NAV_Shuffle)(TRUE);
  202.                         else
  203.                         {
  204.                          err = SAMP(NAV_Shuffle)(FALSE);
  206.                          if(PM_IsPlaybackProgram(PM_GetPlaybackMode()))
  207.                          {
  208.                           //non_program to program
  209.                           err = SAMP(NAV_SetPlaySequence)(SAMP(NAV_PLAY_SEQ_PROGRAM));
  210.                          }
  211.                          else
  212.                          {
  213.                          //non_normal to normal
  214.                          err = SAMP(NAV_SetPlaySequence)(SAMP(NAV_PLAY_SEQ_ALL));
  215.                          }
  217.                         }
  219.                         if(PM_IsRepeatAll())
  220.                          err = SAMP(NAV_Repeat)(SAMP(NAV_REPEAT_ALL));
  221.                         else
  222.                         if(PM_IsRepeatSingle())
  223.                          err = SAMP(NAV_Repeat)(SAMP(NAV_REPEAT_TRACK));
  224.                         else
  225.                          err = SAMP(NAV_Repeat)(SAMP(NAV_REPEAT_OFF));
  227. break;
  229. case IE_CORE_GOTO_TIME:
  230. case IE_CORE_GOTO_DISC_TIME:
  231.                         {
  233.                          SAMP(SACD_TimeCode) Timecode;
  235.                          if(IE_CORE_GOTO_TIME == Event)
  236.                           (ULONG)Param += Nav_SACD_Get_Track_Start_Time(SACD_GLOBALS.currentTrack);
  238.                          Timecode.min = (BYTE)(((ULONG)Param)/60);
  239.                          Timecode.sec = (BYTE)(((ULONG)Param)%60);
  240.                          Timecode.fr = 0;
  242.                          err = SAMP(NAV_PlayAtTimecode)(Timecode);
  244.                         }
  245. #ifdef EXINO2  // <<< SEC CH.KO033104  
  246. ie_send(IE_UI_REFRESH_TIME);           
  247. #endif
  248. break;
  250. case IE_CORE_CDNAV_INTRO:
  251.                         err = SAMP(NAV_IntroScan)(TRUE, (SAMP(UInt8)) SACD_INTRO_TIME);
  252. break;
  254.                   case IE_CORE_SACD_SET_ACTIVE_AREA:
  255.                         err = SAMP(NAV_AreaSwitch)((SAMP(SACD_Area)) Param);
  256.                         SACD_GLOBALS.activeArea = (SAMP(SACD_Area)) Param;
  257.                         break;
  259.                   case IE_CORE_SAMP_NAV_ACTIVATED:
  260.                         //Do APM settings.
  263.      err = SAMP(NAV_SetProgramList)(&(SACD_GLOBALS.ProgramList));
  264.                         err = SAMP(APM_SetInputMode)(SAMP(SACD_IN_DSD));
  266. #ifdef AUDIO_DAC_SUPPORT_DSD
  267.                         err = SAMP(APM_SetOutputMode)(SAMP(APM_OUT_DSD), SAMP(APM_OUT_DSD));
  268. #else
  269.                         err = SAMP(APM_SetOutputMode)(SAMP(APM_OUT_PCM), SAMP(APM_OUT_PCM));
  270. #endif
  272. #if 0 //check later.
  273.                         err = SAMP(APM_Set6chDownmix)((SAMP(APM_6ch_MixDef))(gps->SACD6ChDownmixMode));
  274.                         err = SAMP(APM_Set2chDownmix)((SAMP(APM_2ch_MixDef)) (gps->SACD2ChDownmixMode));
  275.                         err = SAMP(APM_SetSpeakers)((SAMP(APM_SpeakerDef)) (gps->SACDSpeakerMode));
  276.                         {
  277.                          SAMP(UInt16) Attenuation[8];
  278.                          Attenuation[0] = gps->SACDAttenuationLeft;
  279.                          Attenuation[1] = gps->SACDAttenuationRight;
  280.                          Attenuation[2] = gps->SACDAttenuationCenter;
  281.                          Attenuation[3] = gps->SACDAttenuationLfe;
  282.                          Attenuation[4] = gps->SACDAttenuationLs;
  283.                          Attenuation[5] = gps->SACDAttenuationRs;
  284.                          Attenuation[6] = gps->SACDAttenuation2CHLeft;
  285.                          Attenuation[7] = gps->SACDAttenuation2CHRight;
  286.                          err = SAMP(APM_SetAttenuation)(Attenuation);
  287.                         }
  289.                         {
  290.                          SAMP(UInt32) Delay[6];
  291.                          Delay[0] = gps->SACDDelayLeft;
  292.                          Delay[1] = gps->SACDDelayRight;
  293.                          Delay[2] = gps->SACDDelayCenter;
  294.                          Delay[3] = gps->SACDDelayLfe;
  295.                          Delay[4] = gps->SACDDelayLs;
  296.                          Delay[5] = gps->SACDDelayRs;
  297.                          err = SAMP(APM_SetDelay)(Delay);
  298.                         }
  299.                         err = SAMP(APM_SetFilterMode)((SAMP(APM_FilterModeDef)) (gps->SACDFilterMode));
  300.                         err = SAMP(APM_SetBassFilters)((SAMP(APM_BassFrequencyDef)) (gps->SACDBassFrequency), (SAMP(APM_BassSlopeDef)) (gps->SACDBassSlope));
  301. #else
  302.                         {
  303. DEC_LL_OCFG_SETTING ocfg;
  304.                          SAMP(APM_6ch_MixDef) sacd_ocfg;
  305. ocfg = SpeakersConfigTable[gps->SpeakersConfigIndex].mOCFG;
  307.                          switch(ocfg)
  308.                          {
  309. case DEC_LL_OCFG_2_1:
  310. case DEC_LL_OCFG_2_0_SURROUND_COMPATIBLE:
  311. case DEC_LL_OCFG_1_0:
  312. case DEC_LL_OCFG_2_0_NORMAL:
  313.                             sacd_ocfg = SAMP(APM_MIX_6CH_2_0);
  314.                                break;
  316. case DEC_LL_OCFG_2_2:
  317.                              sacd_ocfg = SAMP(APM_MIX_6CH_2_2);
  318.                                break;
  320. case DEC_LL_OCFG_3_2:
  321.                              sacd_ocfg = SAMP(APM_MIX_6CH_3_2);
  322.                                break;
  323. case DEC_LL_OCFG_3_0:
  324. case DEC_LL_OCFG_3_1:
  325.                              sacd_ocfg = SAMP(APM_MIX_6CH_3_0);
  326.                                break;
  327.                         }
  328.                          err = SAMP(APM_Set6chDownmix)(sacd_ocfg);
  329. }
  331.                         err = SAMP(APM_Set2chDownmix)(SAMP(APM_MIX_2CH_DOWNMIX));
  333.                         {
  334. SAMP(APM_SpeakerDef) speakerSetting;
  335. if(SPK_SIZE_SMALL == SpeakersConfigTable[gps->SpeakersConfigIndex].mFrontSpk)
  336.                            {
  337.                             speakerSetting = SAMP(APM_SSS1);
  338.                            }
  339.                            else //front speaker is large
  340.                            {
  341.                             if(SPK_SIZE_LARGE == SpeakersConfigTable[gps->SpeakersConfigIndex].mSurroundSpk)
  342.                             speakerSetting = SAMP(APM_LLL1);
  343. else
  344.                             speakerSetting = SAMP(APM_LSS0);
  346.                               //sacd todo: check when to set SAMP(APM_LSS0_noLFE).
  347.                            }
  349.                         err = SAMP(APM_SetSpeakers)(speakerSetting);
  350.                         }
  352.                         {
  353.                          SAMP(UInt16) Attenuation[8];
  354. memset(Attenuation, 0, 16);
  355.                          err = SAMP(APM_SetAttenuation)(Attenuation);
  356.                         }
  358.                         {
  359.                          SAMP(UInt32) Delay[6];
  360. memset(Delay, 0, 24);
  361.                          err = SAMP(APM_SetDelay)(Delay);
  362.                         }
  363.                         err = SAMP(APM_SetFilterMode)(SAMP(APM_FM_MAX_SNR));
  365. {
  366. SAMP(APM_BassFrequencyDef) bassFreq = SAMP(APM_BASS_FREQ_100);
  367.                            SAMP(APM_BassSlopeDef) bassSlope = SAMP(APM_BASS_SLOPE_18);
  369. #if defined(BM_CUTOFF_120HZ)
  370.                            bassFreq = SAMP(APM_BASS_FREQ_120);
  371. #elif defined(BM_CUTOFF_80HZ)
  372.                            bassFreq = SAMP(APM_BASS_FREQ_80);
  373. #endif
  375. #if defined(BM_SLOPE_24)
  376.                            bassSlope = SAMP(APM_BASS_SLOPE_24);
  377. #elif defined(BM_SLOPE_12)
  378.                            bassSlope = SAMP(APM_BASS_SLOPE_12);
  379. #endif
  381.                          err = SAMP(APM_SetBassFilters)(bassFreq, bassSlope);
  382. }
  383. #endif
  385.                         err = SAMP(APM_SetPcmUpsampling)(SACD_UPSAMPLING_RATE); //active only when output is PCM.
  387.                         err = SAMP(APM_SetPIO)(2176); //doesn't matter?
  389. //                        err = SAMP(NAV_PlayTrack)(1, SACD_GLOBALS.gbPlayPauseArea? 0:1); //todo: remove later.
  390. //todo: check later.                        DAC_SACD_SetMute(FALSE);
  392.                         break;
  393. default:
  394. dbg_printf(("SACD_Nav: Unexpected Event %xn",Event & 0xFF));
  395. break;
  396. }
  398. break;
  400. default:
  401. dbg_printf((" SACD_Nav: Unknown Operation requested %dn", Op));
  402. break;
  403. }
  405.    if(err != SAMP(ERR_OK))
  406.    {
  407. tr_printf((" SACD_Nav: error handling SACD nav event! %dn", Op));
  408.    }
  410. return 0;
  411. }
  414. //jerry todo: remove later.
  415. //int hold_samp = 1;
  417. /*
  418. Desc: initialize and start SAMP.
  419. rtn: Err_OK, succeed so it's a SACD disc.
  420.      otherwise not a SACD disc.
  421. */
  422. static SAMP(ErrCode) Constructor(void)
  423. {
  424.     void (*lFuroreISR)(void);
  425.     SAMP(ErrCode)  lErr = SAMP(ERR_OK);
  427.     //TODO: check if stack overflows with the 2 structs.
  428. //    SAMP(SAMP_AreaInfoDef) stereo;
  429. //    SAMP(SAMP_AreaInfoDef) multi;
  431.     SAMP(Bool) bDiscRecognized = FALSE;
  435.     //initialize SACD_GLOBALS
  436.     SACD_GLOBALS.samp_state = SAMP_NOT_ACTIVATED;
  437.     SACD_GLOBALS.nav_state = NAV_NOT_ACTIVATED;
  438.     SACD_GLOBALS.play_speed = 1;
  439.     SACD_GLOBALS.iCurrentTime = 0;
  440.     SACD_GLOBALS.iCurrentAbsTime = 0;
  441.     SACD_GLOBALS.gbPlayPauseArea = 1;
  442. //    SACD_GLOBALS.channels =
  443.     SACD_GLOBALS.currentTrack = 0;
  444.     SACD_GLOBALS.currentIndex = 0;
  446. #ifndef SACD_AREA_INFO_INSDRAM
  447.     SACD_GLOBALS.StereoAreaInfoPtr = sc_Malloc((sizeof(SAMP(SAMP_AreaInfoDef)) + 3)/4);
  448.     SACD_GLOBALS.MultiAreaInfoPtr = sc_Malloc((sizeof(SAMP(SAMP_AreaInfoDef)) + 3)/4);
  450.     if(NULL == SACD_GLOBALS.StereoAreaInfoPtr || NULL == SACD_GLOBALS.MultiAreaInfoPtr)
  451.     {
  452.      tr_printf(("Fatal! Constructor: can't allocate memory from scratch pad "));
  453.      return SAMP(ERR_FAILED);
  454.     }
  455. #endif
  458. #ifndef SACD_AREA_INFO_INSDRAM
  459.     //todo: ask Philips to save Area info In SC.
  460.     SACD_GLOBALS.pAreaStereo = malloc(sizeof(SAMP(SAMP_AreaInfoDef)));
  461.     SACD_GLOBALS.pAreaMulti = malloc(sizeof(SAMP(SAMP_AreaInfoDef)));
  463.     if(NULL == SACD_GLOBALS.pAreaStereo || NULL == SACD_GLOBALS.pAreaMulti)
  464.     {
  465. tr_printf((" SACD_Nav: Fatal! Heap size too small for SAMP_AreaInfoDefn"));
  467.     }
  468. #else
  469.     {
  470.      UINT32 temp = 0;
  471.      int i;
  472.      for(i = 0; i < 4; i++)
  473.      {
  474.       sc_SetBytes32(SDRAM_2CH_AREA_INFO_BASE, i*4, 4, (const BYTE *)(&temp));
  475.       sc_SetBytes32(SDRAM_MULTICH_AREA_INFO_BASE, i*4, 4, (const BYTE *)(&temp));
  476.      }
  477.     }
  478. #endif
  480. //todo: check later.    DAC_SACD_SetMute(TRUE);
  482. #if 0 //sacd todo: check later.
  483.     //install ISR.
  484.     SAMP(SDM_GetHandler)( &lFuroreISR );
  485.     lErr = SAMP(ISR_Install)( lFuroreISR );
  486. #endif
  488.     if(SAMP(ERR_OK) != lErr)
  489. tr_printf((" SACD_Nav: Fatal! Install ISR failedn"));
  491.     //BE_Init
  492.     lErr = SAMP(BE_Init)();
  494.     if(SAMP(ERR_OK) != lErr)
  495. tr_printf((" SACD_Nav: Fatal! BE_Init failedn"));
  497.     //DAC_Init
  498. //    lErr = SAMP(DAC_Init)();
  500.     if(SAMP(ERR_OK) != lErr)
  501. tr_printf((" SACD_Nav: Fatal! DAC_Init failedn"));
  503.     //SetEngine type as IIS
  504.     lErr = SAMP(SDM_SetEngineType)(SAMP(SDM_BE_I2S));
  506. #if 1 //sacd todo: check later.
  507.     //install ISR.
  508.     SAMP(SDM_GetHandler)( &lFuroreISR );
  509.     lErr = SAMP(ISR_Install)( lFuroreISR );
  510. #endif
  512.     //Set Burst length
  513.     lErr = SAMP(SDM_SetBurstLength)(SACD_BURST_LENGTH);
  517.     //Set Dac Pinning
  518. #ifdef AUDIO_DAC_SUPPORT_DSD
  519.     lErr = SAMP(SDM_SetDacPinning)(0,  0,
  520.                                    0,  0,
  521.                                    0,  0,
  522.                                    0,  0,
  523.                                    0,  0,
  524.                                    0,  0,
  525.                                    SAMP(SDM_DSD_CLOCK), 0, 0);
  526.     //set DSD clock polarity. Doesn't matter with PCM DAC.
  527.     lErr = SAMP(SDM_SetDsdClockPolarity)(1);    //TODO: check later.
  529.     //sacd todo: do external mute. 
  530. //    DAC_Set_DSD_Mode(1);
  531. #else
  532.     lErr = SAMP(SDM_SetDacPinning)(SAMP(SDM_PCM_LEFTFRONT_RIGHTFRONT),  SAMP(SDM_PIO),
  533.                                    SAMP(SDM_PCM_CENTER_LFE),  SAMP(SDM_PIO),
  534.                                    SAMP(SDM_PCM_LEFTSURR_RIGHTSURR), SAMP(SDM_PIO),
  535.                                    SAMP(SDM_PCM_DATACLOCK),  SAMP(SDM_PCM_WORDCLOCK),
  536.                                    SAMP(SDM_PCM_DATACLOCK),  SAMP(SDM_PCM_WORDCLOCK),
  537.                                    SAMP(SDM_PCM_LEFTFRONT_RIGHTFRONT), SAMP(SDM_PIO),
  538.                                    SAMP(SDM_PIO), SAMP(SDM_PIO), SAMP(SDM_PIO));
  539. #endif
  543.     {
  544. #ifdef MASTERCLOCK_256
  545.     SAMP(SDM_AudioClockDef) AudioClock = SAMP(SDM_AUD_CLK_256FS);
  546. #else
  547.     SAMP(SDM_AudioClockDef) AudioClock = SAMP(SDM_AUD_CLK_384FS);
  548. #endif
  549.     //set audio clk, e.g. 384fs. valid for DSD stream.
  550.     lErr = SAMP(SDM_SetAudioClock)(SAMP(SACD_IN_DSD), AudioClock);
  551.     lErr = SAMP(SDM_SetAudioClock)(SAMP(SACD_IN_PCM_44), AudioClock);
  552.     lErr = SAMP(SDM_SetAudioClock)(SAMP(SACD_IN_PCM_88), AudioClock);
  553.     lErr = SAMP(SDM_SetAudioClock)(SAMP(SACD_IN_PCM_176), AudioClock);
  554.     lErr = SAMP(SDM_SetAudioClock)(SAMP(SACD_IN_PCM_48), AudioClock);
  555.     lErr = SAMP(SDM_SetAudioClock)(SAMP(SACD_IN_PCM_96), AudioClock);
  556.     lErr = SAMP(SDM_SetAudioClock)(SAMP(SACD_IN_PCM_192), AudioClock);
  558.     }
  560.     //system clock is 27M hz
  561.     lErr = SAMP(SDM_SetSystemClock)(SYS_CLK);
  563.     //samp init
  564.     lErr = SAMP(SAMP_Init)();
  566.     if(SAMP(ERR_OK) != lErr)
  567. tr_printf((" SACD_Nav: Fatal! SAMP_Init failedn"));
  569.     //SAMP Subscribe
  570.     lErr = SAMP(SAMP_Subscribe)( SampCallback
  571.                               , ( SAMP_ACTIVATED
  572.                                 | SAMP_NOT_ACTIVATED ) );
  574.     //NAV subscribe
  575.     lErr = SAMP(NAV_Subscribe)( NavCallback
  576.                               , ( NAV_ACTIVATED
  577.                                 | NAV_NOT_ACTIVATED
  578.                                 | NAV_STARTED
  579.                                 | NAV_PAUSED
  580.                                 | NAV_STOPPED
  581.                                 | NAV_FINISHED
  582.                                 | NAV_PROGRESS_INFO
  583.                                 | NAV_MODE_CHANGE
  584.                                 | NAV_WARNING
  585.                                 | NAV_ERROR
  586.                                 | NAV_CHANNELS_CONFIG) );
  589.     //SAMP activate
  590. #ifdef SACD_AREA_INFO_INSDRAM
  591.     lErr = SAMP(SAMP_Activate)(bDiscRecognized, NULL, NULL, (SAMP(Bool) *)&(SACD_GLOBALS.hybrid));
  592. #else
  593.     lErr = SAMP(SAMP_Activate)(bDiscRecognized, SACD_GLOBALS.pAreaStereo, SACD_GLOBALS.pAreaMulti, (SAMP(Bool) *)&(SACD_GLOBALS.hybrid));
  594. #endif
  596.     if(SAMP(ERR_OK) != lErr)
  597. tr_printf((" SACD_Nav: Fatal! SAMP_Activate failedn"));
  600.     return lErr;
  601. }
  603. /*
  604. desc: kill SAMP.
  605. */
  606. static void Destructor(void)
  607. {
  608.   SAMP(ErrCode)  lErr = SAMP(ERR_OK);
  610.   SAMP(NAV_StateDef) stateDef;
  612.   SAMP(NAV_GetState)(&stateDef);
  614.   //todo: check with Philips jerry cai
  615.   stateDef.PlayState = SAMP(NAV_PLAYING);
  617.   // First make sure it is deactivated!
  618.   switch (stateDef.PlayState)
  619.   {
  620.   case SAMP(NAV_PLAY_CALLED):
  621.   case SAMP(NAV_PLAYING):
  622.   case SAMP(NAV_PAUSE_CALLED):
  623. //todo: check with philips  case SAMP(NAV_PAUSED):
  624.       lErr |= SAMP(NAV_Stop)();
  626.     // fall through
  627.   case SAMP(NAV_STOP_CALLED):
  629.     // fall through
  630. //todo: check with philips.  case SAMP(NAV_STOPPED):
  631.   case SAMP(NAV_ACTIVATING):
  633.        lErr |= SAMP(NAV_Subscribe)( NavCallback, 0);
  634. //       lErr |= SAMP(SAMP_Subscribe)( SampCallback, 0 );
  636.        //sacd todo: check later.
  637.        lErr |= SAMP(SAMP_Deactivate)();
  639.     // fall through
  640.   case SAMP(NAV_DEACTIVATED):
  641.   case SAMP(NAV_NOT_ACTIVATED):
  642.     {
  643.       // Deactivated -> nothing to be done!
  644.     }
  645.     break;
  647.   default:
  648.     {
  649.      tr_printf(("Warning: Nav_SACD_Desctructor: Unknown nav state"));
  650.     }
  651.     break;
  652.   }
  654.   DAC_SACD_SetMute(TRUE);
  656.   //IIS is back to PCM mode. In this order noise is minimized during the transition.
  657.   SAMP(BE_Term)();
  660. // <<< SEC shKang042304 : when power off, spindle has to be stopped by coremain
  661. if (g_power_state == POWER_SEQUENCE_OFF_REQUESTED)
  662. {
  663. tr_printf(("n auto spindown because of power off !!! n "));
  664. PE_SACD_AbortPlayback(0);
  665. }
  666. // SEC shKang042304 >>>
  668.   
  669. #ifdef AUDIO_DAC_SUPPORT_DSD
  670. //  DAC_Set_DSD_Mode(0); //back to pcm mode.
  671. #else
  672.   lErr = SAMP(APM_SetInputMode)(SAMP(SACD_IN_PCM_44));
  674.   lErr = SAMP(APM_SetOutputMode)(SAMP(APM_OUT_BPS), SAMP(APM_OUT_BPS));
  675. #endif
  678.   lErr |= SAMP(SAMP_Term)();
  680.   SACD_ISR_Uninstall();
  682.   DAC_SACD_SetMute(FALSE);
  684.   //set Furore chip to bypass mode.
  685. //  FuroreSetExternalInputPCMMode();
  687. #ifndef SACD_AREA_INFO_INSDRAM
  688.   sc_Free(SACD_GLOBALS.StereoAreaInfoPtr, (sizeof(SAMP(SAMP_AreaInfoDef)) + 3)/4);
  689.   sc_Free(SACD_GLOBALS.MultiAreaInfoPtr, (sizeof(SAMP(SAMP_AreaInfoDef)) + 3)/4);
  690. #endif
  692.   if(SAMP(ERR_OK) != lErr){
  693.    tr_printf(("FATAL NAV_SACD: fail in destructor.n"));
  694.   }
  696. }
  700. /*
  701. Desc: call back function for SAMP events.
  702. */
  703. static void SampCallback(SAMP(BitSet32) Event, void * EventData)
  704. {
  705.   switch( Event )
  706.   {
  708.   case SAMP_ACTIVATED :
  710.     DAC_Set_DSD_Mode(1); //todo: check later.
  712.  g_disc_is_hybrid_sacd = SACD_GLOBALS.hybrid;
  714.     SACD_GLOBALS.samp_state = SAMP_ACTIVATED;
  715. #ifdef SACD_AREA_INFO_INSDRAM
  716.     //todo: update  SACD_GLOBALS.activeArea
  717.     if(Nav_SACD_Get_Num_Of_Tracks(SAMP(SACD_AREA_MULTICHANNEL)) > 0)
  718.      SACD_GLOBALS.activeArea = SAMP(SACD_AREA_MULTICHANNEL);
  719.     else
  720.      SACD_GLOBALS.activeArea = SAMP(SACD_AREA_STEREO);
  722. #else
  723.     SaveSACDAreaInfo(SACD_GLOBALS.pAreaStereo, SACD_GLOBALS.pAreaMulti);
  725.     if(SACD_GLOBALS.pAreaMulti->NumberOfTracks > 0)
  726.      SACD_GLOBALS.activeArea = SAMP(SACD_AREA_MULTICHANNEL);
  727.     else
  728.      SACD_GLOBALS.activeArea = SAMP(SACD_AREA_STEREO);
  730.     if(NULL != SACD_GLOBALS.pAreaStereo)
  731.     {
  732.      free(SACD_GLOBALS.pAreaStereo);
  733.      SACD_GLOBALS.pAreaStereo = NULL;
  734.     }
  736.     if(NULL != SACD_GLOBALS.pAreaMulti)
  737.     {
  738.      free(SACD_GLOBALS.pAreaMulti);
  739.      SACD_GLOBALS.pAreaMulti = NULL;
  740.     }
  741. #endif
  744.   break;
  746.   case SAMP_NOT_ACTIVATED:
  748.     SACD_GLOBALS.samp_state = SAMP_NOT_ACTIVATED;
  750.     ie_send(IE_CORE_SACD_IDENTIFICATION_FAILED);
  752.   break;
  754.   default:
  755.     tr_printf(( "Unknown SAMP event received" ));
  756.   break;
  757.   }
  758. }
  761. //extern int track_playing;//jerry todo: remove later.
  762. /*
  763. Desc: callback function for NAV events.
  764. */
  765. static void NavCallback(SAMP(BitSet32) Event, void * EventData)
  766. {
  768.   SAMP(ErrCode)  lErr = SAMP(ERR_OK);
  769.   SACD_GLOBALS.nav_state = Event;
  771.   switch( Event )
  772.   {
  773.   case NAV_ACTIVATED:
  776. #if 1 //jerry cai //todo: check later.
  777.  gcs.mstate = MST_DISC_READY; //UI will detect this state change then open SACD menu and issue restart.
  778. #endif
  779.  gcs.pstate= PST_STOP;
  780.  CLEAR_COP_MASK(0xFFFFFFFFL);
  783.  SET_COP_MASK(COP_RESTART|COP_PLAY|COP_TIME_PLAY|COP_SEAMLESS_MODE_CHANGE);//scan is not allowed by SAMP yet.
  785. //    DAC_SACD_SetMute(FALSE);
  786.     ie_send(IE_CORE_SAMP_NAV_ACTIVATED);
  789.     break;
  790.   case NAV_NOT_ACTIVATED:
  791.  gcs.pstate= PST_STOP;
  792.  CLEAR_COP_MASK(0xFFFFFFFFL);
  794.  SET_COP_MASK(COP_EJECT|COP_SETUP);
  796.     break;
  798.   case NAV_STARTED:
  799. //    track_playing = 1; //jerry todo: remove later.
  800. #if 0 //jerry cai //todo: check later.
  801.  gcs.mstate = MST_DISC_READY; //UI will detect this state change then open SACD menu and issue restart.
  802. #endif
  804.  CLEAR_COP_MASK(COP_PLAY);
  806.  SET_COP_MASK(COP_STOP|COP_PAUSE|COP_SCAN|COP_SCAN_BACKWARD|COP_NEXT_CHAPTER|
  807.                  COP_PREVIOUS_CHAPTER|COP_REVERSE_PLAY|COP_ABREPEAT);
  808.  gcs.pstate= PST_PLAY;
  809.     {
  810.      SACD_GLOBALS.play_speed = *((SAMP(Int16) *) EventData);
  812.      if(1 != SACD_GLOBALS.play_speed)
  813.      {
  814.    gcs.pstate= PST_SCAN;  //either forward or backward
  815.    SET_COP_MASK(COP_PLAY); //for SAMP, play command will resume normal speed playback.
  816.      }
  817.     }
  818.     break;
  820.   case NAV_PAUSED:
  821.  CLEAR_COP_MASK(COP_PAUSE);
  822.     SET_COP_MASK(COP_PLAY); //scan, next/prev is allowed in pause state.
  823.  gcs.pstate= PST_PAUSE;
  824.     break;
  826.   case NAV_STOPPED:
  827.   //Does it mean the whole play list has been finished?
  828.   case NAV_FINISHED:
  829.  CLEAR_COP_MASK(COP_STOP|COP_PAUSE|COP_SCAN|COP_SCAN_BACKWARD|COP_NEXT_CHAPTER|
  830.                  COP_PREVIOUS_CHAPTER|COP_REVERSE_PLAY|COP_ABREPEAT); //time play is allowed
  831.     SET_COP_MASK(COP_PLAY);
  832.  gcs.pstate= PST_STOP;
  833. // <<< SEC shKang042204 : after finishing the total track, has to be a full stop status.
  834. #ifdef EXINO2
  835. g_in_full_stop = TRUE;
  836. #endif // EXINO2
  837. // SEC shKang042204 >>>
  838.     break;
  840.   case NAV_PROGRESS_INFO:
  841.     {
  842.     SAMP(NAV_ProgressInfoDef) *info = (SAMP(NAV_ProgressInfoDef) *) EventData;
  843.     SACD_GLOBALS.iCurrentTime = info->rel_time.min*60 + info->rel_time.sec;
  845. #ifdef SACD_DO_NOT_DISPLAY_COUNT_DOWN_IN_PAUSE_AREA
  846.     if(0 == info->index)
  847.     SACD_GLOBALS.iCurrentTime = 0;
  848. #endif
  850.     SACD_GLOBALS.iCurrentAbsTime = info->abs_time.min*60 + info->abs_time.sec;
  852.     ie_send(IE_UI_TIME_UPDATE);
  854.     if(SACD_GLOBALS.currentTrack != info->track)
  855.      ie_send(IE_UI_TRACK_UPDATE);
  857.     SACD_GLOBALS.currentTrack = info->track;
  858.     SACD_GLOBALS.currentIndex = info->index;
  860.     }
  861.     break;
  862.   case NAV_MODE_CHANGE:
  863.     {
  864.     SAMP(NAV_ModeChangeDef) mode = *(SAMP(NAV_ModeChangeDef) *) EventData;
  866.     if(mode.reshuffled)
  867.     {
  868.      dbg_printf(("SAMP reshuffled"));
  869.     }
  871.     if(mode.repeat_ab_canceled)
  872.      PM_SetRepeatAB(0);
  874.     }
  875.     break;
  877.   case NAV_WARNING:
  878.     {
  879.     SAMP(NAV_WarningCodeDef) warningCode = *(SAMP(NAV_WarningCodeDef) *) EventData;
  880.     dbg_printf(("SAMP EventWarning: 0x%lx ", warningCode));
  881.     }
  882.     break;
  884.   case NAV_ERROR:
  885.     {
  886.     SAMP(NAV_ErrorCodeDef) errorCode = *(SAMP(NAV_ErrorCodeDef) *) EventData;
  887.     dbg_printf(("SAMP Eventerror: 0x%lx ", errorCode));
  888.     }
  889.     break;
  891.   case NAV_CHANNELS_CONFIG:
  892.     {
  893.     SACD_GLOBALS.channels = *((SAMP(SACD_ChannelsConfigDef) *)EventData);
  894.     }
  895.     break;
  896.   default:
  897.     dbg_printf(("SAMP Unkown Event"));
  898.   break;
  899.   }
  900. }
  904. /*TODO: ask Philips to put the info directly in Scratch pad*/
  906. #ifndef SACD_AREA_INFO_INSDRAM
  907. static void SaveSACDAreaInfo(SAMP(SAMP_AreaInfoDef) *stereo,SAMP(SAMP_AreaInfoDef) *multi)
  909. {
  911.   sc_Write(SACD_GLOBALS.StereoAreaInfoPtr, (sizeof(SAMP(SAMP_AreaInfoDef)) + 3)/4, (const Sc_cont *)stereo);
  914.   sc_Write(SACD_GLOBALS.MultiAreaInfoPtr, (sizeof(SAMP(SAMP_AreaInfoDef)) + 3)/4, (const Sc_cont *)multi);
  918. }
  919. #endif
  922. UINT16 Nav_SACD_Get_Track_Start_Time(UINT16 trackNo)
  924. {
  926. #ifdef SACD_AREA_INFO_INSDRAM
  927.   DWORD areaStartAddr = (SAMP(SACD_AREA_MULTICHANNEL) == SACD_ACTIVE_AREA)? SDRAM_MULTICH_AREA_INFO_BASE :
  929.                                                                          SDRAM_2CH_AREA_INFO_BASE;
  930. #else
  931.   WORD areaStartAddr = (SAMP(SACD_AREA_MULTICHANNEL) == SACD_ACTIVE_AREA)? SACD_GLOBALS.MultiAreaInfoPtr :
  933.                                                                          SACD_GLOBALS.StereoAreaInfoPtr;
  934. #endif
  936.   WORD i_hAddress;
  938.   char buff[8];
  940.   UINT16 startTime;
  942.   BYTE offset;
  944.   if(trackNo == 0) // track starts from 1.
  945.    return 0;
  947.   trackNo --;
  950. #ifdef SACD_AREA_INFO_INSDRAM
  951.   sc_GetBytes32(areaStartAddr, TRACK_START_INFO_LOCATION(trackNo), 2, buff);
  952.   startTime = buff[0]*60 + buff[1];
  953. #else
  954.   offset = TRACK_START_INFO_LOCATION(trackNo)%4;
  955.   i_hAddress = areaStartAddr + TRACK_START_INFO_LOCATION(trackNo)/4;
  956.   sc_Read(i_hAddress, 2, (Sc_cont *)buff);
  957.   startTime = buff[offset]*60 + buff[offset + 1];
  958. #endif
  961.   return startTime;
  963. }
  966. /*
  967. Desc: Get the length of a track. The information is retrieved from scratch pad.
  968. */
  969. UINT16 Nav_SACD_Get_Track_Length(UINT16 trackNo)
  970. {
  972. #ifdef SACD_AREA_INFO_INSDRAM
  973.   DWORD areaStartAddr = (SAMP(SACD_AREA_MULTICHANNEL) == SACD_ACTIVE_AREA)? SDRAM_MULTICH_AREA_INFO_BASE :
  975.                                                                          SDRAM_2CH_AREA_INFO_BASE;
  976. #else
  977.   WORD areaStartAddr = (SAMP(SACD_AREA_MULTICHANNEL) == SACD_ACTIVE_AREA)? SACD_GLOBALS.MultiAreaInfoPtr :
  979.                                                                          SACD_GLOBALS.StereoAreaInfoPtr;
  980. #endif
  982.   WORD i_hAddress;
  984.   char buff[8];
  986.   UINT16 time;
  988.   BYTE offset;
  992.   if(trackNo == 0) // track starts from 1.
  993.    return 0;
  995. #if 0
  996.   startTime = Nav_SACD_Get_Track_Start_Time(trackNo);
  998.   if(trackNo == Nav_SACD_Get_Num_Of_Tracks(SACD_ACTIVE_AREA))
  999.    endTime = Nav_SACD_Get_Total_Time(SACD_ACTIVE_AREA);
  1000.   else
  1001.    endTime = Nav_SACD_Get_Track_Start_Time(trackNo+1);
  1003.   return endTime - startTime;
  1004. #endif
  1007.   trackNo --;
  1009. #ifdef SACD_AREA_INFO_INSDRAM
  1010.   sc_GetBytes32(areaStartAddr, 5 + Nav_SACD_Get_Num_Of_Tracks(SACD_ACTIVE_AREA)*3 + trackNo*3, 2, buff);
  1011.   time = buff[0]*60 + buff[1];
  1012. #else
  1013.   offset = TRACK_LEN_INFO_LOCATION(trackNo)%4;
  1014.   i_hAddress = areaStartAddr + TRACK_LEN_INFO_LOCATION(trackNo)/4;
  1015.   sc_Read(i_hAddress, 2, (Sc_cont *)buff);
  1016.   time = buff[offset]*60 + buff[offset + 1];
  1017. #endif
  1023.   return time;
  1025. }
  1029. /*
  1031. Desc: get number of tracks in an area.
  1033. */
  1035. UINT16 Nav_SACD_Get_Num_Of_Tracks(SAMP(SACD_Area) area)
  1037. {
  1039.   char buff[4];
  1041.   UINT16 res;
  1043. #ifdef SACD_AREA_INFO_INSDRAM
  1044.   DWORD areaStartAddr = (SAMP(SACD_AREA_MULTICHANNEL) == area)? SDRAM_MULTICH_AREA_INFO_BASE :
  1045.                                                                          SDRAM_2CH_AREA_INFO_BASE;
  1046. #else
  1047.   WORD areaStartAddr = (SAMP(SACD_AREA_MULTICHANNEL) == area)? SACD_GLOBALS.MultiAreaInfoPtr :
  1048.                                                                          SACD_GLOBALS.StereoAreaInfoPtr;
  1049. #endif
  1052. #ifdef SACD_AREA_INFO_INSDRAM
  1053.   sc_GetBytes32(areaStartAddr, 0, 4, buff);
  1054. #else
  1055.   sc_Read(areaStartAddr, 1, (Sc_cont *)buff);
  1056. #endif
  1060.   res = (UINT16)buff[0];
  1062.   res &= 0xff; //todo: check with Philips.
  1064.   return res;
  1066. }
  1068. UINT16 Nav_SACD_Get_Total_Time(SAMP(SACD_Area) area)
  1069. {
  1071.   char buff[2];
  1073.   UINT16 res;
  1075. #ifdef SACD_AREA_INFO_INSDRAM
  1076.   DWORD areaStartAddr = (SAMP(SACD_AREA_MULTICHANNEL) == area)? SDRAM_MULTICH_AREA_INFO_BASE :
  1078.                                                                          SDRAM_2CH_AREA_INFO_BASE;
  1079. #else
  1080.   WORD areaStartAddr = (SAMP(SACD_AREA_MULTICHANNEL) == area)? SACD_GLOBALS.MultiAreaInfoPtr :
  1082.                                                                          SACD_GLOBALS.StereoAreaInfoPtr;
  1083. #endif
  1086. #ifdef SACD_AREA_INFO_INSDRAM
  1087.   sc_GetBytes32(areaStartAddr, 2, 2, buff);   //tod: was 4 check with Philips.
  1088. #else
  1089.   sc_GetBytes(areaStartAddr, 4, 2, buff);
  1090. #endif
  1092.   res = (UINT16)buff[0]*60 + buff[1];
  1094.   return res;
  1096. }
  1098. #endif // D_SUPPORT_SACD