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

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

DVD

开发平台：

Others

SAMP_API.c：源码内容
  1. #include "Config.h" // Global Configuration - do not remove!
  3. #if D_SUPPORT_SACD // ZKR GLSACD
  4. #if 1 ////////////////////////////////////////////////////////////////////////////////////////
  6. #include "IncludeSysDefs.h"
  7. #include "PlaycoreCoremaincoremain.h"
  8. #include "KerneluITRONrtos.h"
  9. #include "KernelKer_API.h"
  10. #include "KernelEventDef.h"
  12. #include "PlaycoreSAMPschedulerSAMPScheduler.h"
  13. #include "PlaycoreSAMPschedulerSAMP_API.h"
  15. #define SAMP_READY
  17. #ifdef SAMP_READY
  19. #include "playcoresampsamp_apm.h"
  20. #include "playcoresampsamp_nav.h"
  21. #include "playcoresampsamp_sdi.h"
  22. #include "playcoresampsamp_sdm.h"
  24. #endif
  28. #ifdef dbg_printf
  29. #undef dbg_printf
  30. #define dbg_printf(sMsg) printf ## sMsg
  31. #endif
  34. // *****************************************************************************
  35. // * External referencies
  36. // *****************************************************************************
  37. extern int SchedulerID;
  39. // *****************************************************************************
  40. // * Global variable
  41. // *****************************************************************************
  42. //keeps error code for API function calls
  43. SAMP(ErrCode) errorCode;
  45. static BOOL gbSAMP_APICallFinished = 0;
  47. // *****************************************************************************
  48. // * Function prototypes
  49. // *****************************************************************************
  50. SAMP(ErrCode) SAMP_API_Start (void);
  53. // *****************************************************************************
  54. // * Purpose          : Send event to CORE dispatcher and wait for the answer
  55. // * Input Parameters : APIFunction - ID of called API function
  56. // *                    errPtr - error code return by called API function
  57. // * Return Value     : TRUE - API function call executed succesfuly
  58. // *    FALSE - API function call failed
  59. // * Description : The APICallSend will send event to CORE handler 
  60. // *                   dispatcher. The parameter is required ID of API function
  61. // *                   call. The functions wait for API execution finished
  62. // * Comments   : Need to figur out correct parameter passing
  63. // *****************************************************************************
  64. BOOL SAMP_APICallRequest (UINT32 APIFunction, SAMP(ErrCode) *errPtr)
  65. {
  66. // ER SAMP(ErrCode) = E_OK;
  67.    if (SchedulerID == -1)
  68.    {
  69. tr_printf (("SAMP Scheduler is not installedn"));
  70.     return FALSE;
  71.    }
  73.    gbSAMP_APICallFinished = 0;
  74.    
  75. //send request to call API function
  76. if (!ie_send_ex(IE_CORE_SAMP_API, (void *)(APIFunction)))
  77.    {
  78.     tr_printf (("SAMP_APICall failure - sent eventn"));
  79.       return FALSE;
  80.    }
  82.    //wait for the confirmation and error code
  83. //   SAMP(ErrCode) = wai_sem(SEM_SAMP);
  86.    while(gbSAMP_APICallFinished == 0) usleep(1000UL);
  88. #if 0
  89. if (SAMP(ErrCode) != E_OK)
  90.    {
  91.     tr_printf (("SAMP_APICall failure - wait for semaphoren"));
  92.       return FALSE;
  93.    }
  94. #endif   
  96.    *errPtr = errorCode;
  97. return TRUE;
  98. }
  102. // *****************************************************************************
  103. // * Purpose          : Acknowledge the API function call is finished
  104. // * Input Parameters : err - error code return by API function call
  105. // * Return Value     : TRUE - API function call executed succesfuly
  106. // *    FALSE - API function call failed
  107. // * Description :
  108. // *****************************************************************************
  109. BOOL SAMP_APICallAcknowledge (SAMP(ErrCode) err)
  110. {
  111. //confirm the comand is executed and return the ERROR code
  112. errorCode = err;
  113.    gbSAMP_APICallFinished = 1;
  115.    return 1;
  116. //   return (sig_sem(SEM_SAMP) == E_OK);
  117. }
  120. #ifdef SAMP_READY
  122. #ifdef TEST_HARNASS
  124. // *****************************************************************************
  125. // * Purpose          : handle the NAV API function call event
  126. // * Input Parameters : err - error code return by API function call
  127. // * Return Value     : TRUE - API function call executed succesfuly
  128. // *    FALSE - API function call failed
  129. // * Description :
  130. // *****************************************************************************
  131. static SAMP(ErrCode) SAMP_NAV_API_Handler(UINT32 param)
  132. {
  133. SAMP(ErrCode) err = SAMP(ERR_OK);
  135.      switch(param)
  136.      {
  137.       case NAV_AREASWITCH:
  138.       {
  139.         SAMP(SACD_Area) Area = (SAMP(SACD_Area))SAMP_API_PARAM[0];
  140.         err = SAMP(NAV_AreaSwitch)(Area);
  141.         break;
  142.       }
  143.       case NAV_PLAYATTIMECODE:
  144.       {
  145.         SAMP(SACD_TimeCode) Timecode;
  146.         Timecode.min = (BYTE)SAMP_API_PARAM[0];
  147.         Timecode.sec = (BYTE)SAMP_API_PARAM[1];
  148.         Timecode.fr = (BYTE)SAMP_API_PARAM[2];
  150.         err = SAMP(NAV_PlayAtTimecode)(Timecode);
  151.         break;
  152.       }
  153.       case NAV_PLAYTRACK:
  154.       {
  155.         SAMP(UInt16) track = (SAMP(UInt16))SAMP_API_PARAM[0];
  156.         SAMP(UInt16) index = (SAMP(UInt16))SAMP_API_PARAM[1];
  157.         err = SAMP(NAV_PlayTrack)(track, index);
  158.         break;
  159.       }
  161.       case NAV_STOP:
  162.       {
  163.         err = SAMP(NAV_Stop)();
  164.         break;
  165.       }
  166.       case NAV_PAUSE:
  167.         err = SAMP(NAV_Pause)();
  168.         break;
  169.       case NAV_RESUMEPLAY:
  170.         err = SAMP(NAV_ResumePlay)();
  171.         break;
  172.       case NAV_NEXTTRACK:
  173.         err = SAMP(NAV_NextTrack)();
  174.         break;
  175.       case NAV_PREVIOUSTRACK:
  176.         err = SAMP(NAV_PreviousTrack)();
  177.         break;
  178.       case NAV_FORWORDSCAN:
  179.       {
  180.         SAMP(UInt8) Speed = (SAMP(UInt8))SAMP_API_PARAM[0];
  181.         err = SAMP(NAV_ForwardScan)(Speed);
  182.         break;
  183.       }
  184.       case NAV_BACKWORDSCAN:
  185.       {
  186.         SAMP(UInt8) Speed = (SAMP(UInt8))SAMP_API_PARAM[0];
  187.         err = SAMP(NAV_BackwardScan)(Speed);
  188.         break;
  189.       }
  190.       case NAV_REPEAT:
  191.       {
  192.         SAMP(NAV_RepeatModeDef) RepeatMode = (SAMP(NAV_RepeatModeDef))SAMP_API_PARAM[0];
  193.         err = SAMP(NAV_Repeat)(RepeatMode);
  194.         break;
  195.       }
  198.       case NAV_REPEATAB:
  199.       {
  200.         SAMP(NAV_RepeatABModeDef) RepeatABMode = (SAMP(NAV_RepeatABModeDef))SAMP_API_PARAM[0];
  201.         err = SAMP(NAV_RepeatAB)(RepeatABMode);
  202.         break;
  203.       }
  204.       case NAV_SHUFFLE:
  205.       {
  206.         SAMP(Bool) ShuffleMode = (SAMP(Bool))SAMP_API_PARAM[0];
  207.         err = SAMP(NAV_Shuffle)(ShuffleMode);
  208.         break;
  209.       }
  211.       case NAV_INTROSCAN:
  212.       {
  213.         SAMP(Bool) IntroScanMode = (SAMP(Bool))SAMP_API_PARAM[0];
  214.         SAMP(UInt8) Duration = SAMP_API_PARAM[1];
  215.         err = SAMP(NAV_IntroScan)(IntroScanMode, Duration);
  216.         break;
  217.       }
  218.       case NAV_SETPLAYSEQUENCE:
  219.       {
  220.         SAMP(NAV_PlaySequenceDef) PlaySequence = (SAMP(NAV_PlaySequenceDef))SAMP_API_PARAM[0];
  221.         err = SAMP(NAV_SetPlaySequence)(PlaySequence);
  222.         break;
  223.       }
  224.       case NAV_PLAYSEQUENCEDEF:
  225.       {
  226.         SAMP(NAV_ProgramListDef) *ProgramList = (SAMP(NAV_ProgramListDef) *)SAMP_API_PARAM[0];
  227.         err = SAMP(NAV_SetProgramList)(ProgramList);
  228.         break;
  229.       }
  230.       case NAV_SUBSCRIBE:
  231.       {
  232.         SAMP(NAV_CallbackDef) Callback = (SAMP(NAV_CallbackDef))SAMP_API_PARAM[0];
  233.         SAMP(BitSet32) Events = SAMP_API_PARAM[1];
  234.         err = SAMP(NAV_Subscribe)(Callback, Events);
  235.         break;
  236.       }
  237.       case NAV_SUBSCRIBE_1394:
  238.       {
  239.         SAMP(NAV_CallbackDef) Callback = (SAMP(NAV_CallbackDef))SAMP_API_PARAM[0];
  240.         SAMP(BitSet32) Events = SAMP_API_PARAM[1];
  241.         err = SAMP(NAV_Subscribe_1394)(Callback, Events);
  242.         break;
  243.       }
  244.       case NAV_GETSTATE:
  245.       {
  246.         SAMP(NAV_StateDef) *PState = (SAMP(NAV_StateDef) *)SAMP_API_PARAM[0];
  247.         err = SAMP(NAV_GetState)(PState);
  248.         break;
  249.       }
  250.       case NAV_GETPLAYLIST:
  251.       {
  252.         SAMP(NAV_ProgramListDef) *ProgramList = (SAMP(NAV_ProgramListDef) *)SAMP_API_PARAM[0];
  253.         err = SAMP(NAV_GetPlayList)(ProgramList);
  254.         break;
  255.       }
  257.      }
  259.    return err;
  260. }
  264. // *****************************************************************************
  265. // * Purpose          : handle the SDM API function call event
  266. // * Input Parameters : err - error code return by API function call
  267. // * Return Value     : TRUE - API function call executed succesfuly
  268. // *    FALSE - API function call failed
  269. // * Description :
  270. // *****************************************************************************
  271. static SAMP(ErrCode) SAMP_SDM_API_Handler(UINT32 param)
  272. {
  273. SAMP(ErrCode) err = SAMP(ERR_OK);
  274.      switch(param)
  275.      {
  277.       case  SDM_GETHANDLER:
  278.       {
  279.         SAMP(SDM_PVoidFuncDef) *ph = SAMP_API_PARAM[0];
  280.         SAMP(SDM_GetHandler)(ph);
  281.         break;
  282.       }
  283.       case  SDM_SETENGINETYPE:
  284.       {
  285.         SAMP(SDM_EngineTypeDef) Engine = SAMP_API_PARAM[0];
  286.         err = SAMP(SDM_SetEngineType)(Engine);
  287.         break;
  288.       }
  289.       case  SDM_SETDACPINNING:
  290.       {
  292.          SAMP(SDM_DataLineDef) PcmLine0 = SAMP_API_PARAM[0] & 0xf;
  293.          SAMP(SDM_DataLineDef) PcmLine1 = (SAMP_API_PARAM[0]>>8) & 0xf;
  294.          SAMP(SDM_DataLineDef) PcmLine2 = (SAMP_API_PARAM[0]>>16) & 0xf;
  295.          SAMP(SDM_DataLineDef) PcmLine3 = (SAMP_API_PARAM[0]>>24) & 0xf;
  296.          SAMP(SDM_DataLineDef) PcmLine4 = SAMP_API_PARAM[1] & 0xf;
  297.          SAMP(SDM_DataLineDef) PcmLine5 = (SAMP_API_PARAM[1]>>8) & 0xf;
  298.          SAMP(SDM_DataLineDef) PcmLine6 = (SAMP_API_PARAM[1]>>16) & 0xf;
  299.          SAMP(SDM_DataLineDef) PcmLine7 = (SAMP_API_PARAM[1]>>24) & 0xf;
  300.          SAMP(SDM_DataLineDef) PcmLine8 = (SAMP_API_PARAM[2]) & 0xf;
  301.          SAMP(SDM_DataLineDef) PcmLine9 = (SAMP_API_PARAM[2]>>8) & 0xf;
  302.          SAMP(SDM_DataLineDef) PcmLine10 = (SAMP_API_PARAM[2]>>16) & 0xf;
  303.          SAMP(SDM_DataLineDef) PcmLine11 = (SAMP_API_PARAM[2]>>24) & 0xf;
  304.          SAMP(SDM_DataLineDef) DsdLine6 = (SAMP_API_PARAM[3]) & 0xf;
  305.          SAMP(SDM_DataLineDef) DsdLine7 = (SAMP_API_PARAM[3]>>8) & 0xf;
  306.          SAMP(SDM_DataLineDef) DsdLine9 = (SAMP_API_PARAM[3]>>16) & 0xf;
  308.         err = SAMP(SDM_SetDacPinning)
  309.          (  PcmLine0
  310.          ,  PcmLine1
  311.          ,  PcmLine2
  312.          ,  PcmLine3
  313.          ,  PcmLine4
  314.          ,  PcmLine5
  315.          ,  PcmLine6
  316.          ,  PcmLine7
  317.          ,  PcmLine8
  318.          ,  PcmLine9
  319.          ,  PcmLine10
  320.          ,  PcmLine11
  321.          ,  DsdLine6
  322.          ,  DsdLine7
  323.          ,  DsdLine9);
  325.         break;
  326.       }
  327.       case  SDM_SETDSDCLKPOLARITY:
  328.       {
  329.         SAMP(Bool) Positive = SAMP_API_PARAM[0];
  330.         err = SAMP(SDM_SetDsdClockPolarity)(Positive);
  331.         break;
  332.       }
  333.       case  SDM_SETAUDIOCLK:
  334.       {
  335.         SAMP(SACD_InputModeDef) InputMode = SAMP_API_PARAM[0];
  336.         SAMP(SDM_AudioClockDef) AudioClock = SAMP_API_PARAM[1];
  337.         err = SAMP(SDM_SetAudioClock)(InputMode,
  338.                                       AudioClock);
  339.         break;
  340.       }
  341.       case  SDM_SETSYSCLK:
  342.       {
  343.         SAMP(UInt32) SystemClock = SAMP_API_PARAM[0];
  344.         err = SAMP(SDM_SetSystemClock)(SystemClock);
  345.         break;
  346.       }
  347.       case  SDM_SETBURSTLEN:
  348.       {
  349.         SAMP(UInt16) BurstLength = SAMP_API_PARAM[0];
  350.         err = SAMP(SDM_SetBurstLength)(BurstLength);
  351.         break;
  352.       }
  353.       case  SDM_ENA_DTCP:
  354.       {
  355.         SAMP(Bool) enableDTCP = (SAMP(Bool))SAMP_API_PARAM[0];
  356.         err = SAMP(SDM_EnableDTCP)(enableDTCP);
  357.         break;
  358.       }
  360.      }
  361.    return err;
  362. }
  364. // *****************************************************************************
  365. // * Purpose          : handle the APM API function call event
  366. // * Input Parameters : err - error code return by API function call
  367. // * Return Value     : TRUE - API function call executed succesfuly
  368. // *    FALSE - API function call failed
  369. // * Description :
  370. // *****************************************************************************
  371. static SAMP(ErrCode) SAMP_APM_API_Handler(UINT32 param)
  372. {
  373.   SAMP(ErrCode) err = SAMP(ERR_OK);
  374.      switch(param)
  375.      {
  377.       case  APM_SET_INPUTMODE:
  378.       {
  379.         SAMP(SACD_InputModeDef) InputStream = SAMP_API_PARAM[0];
  380.         err = SAMP(APM_SetInputMode)(InputStream);
  381.         break;
  382.       }
  383.       case  APM_SET_OUTPUTMODE:
  384.       {
  385.         SAMP(APM_OutputModeDef) out_mode_6ch = SAMP_API_PARAM[0];
  386.         SAMP(APM_OutputModeDef) out_mode_2ch = SAMP_API_PARAM[1];
  387.         err = SAMP(APM_SetOutputMode)(out_mode_6ch, out_mode_2ch);
  388.         break;
  389.       }
  390.       case  APM_SET_6CHDOWNMIX:
  391.       {
  392.         SAMP(APM_6ch_MixDef) Downmix = SAMP_API_PARAM[0];
  393.         err = SAMP(APM_Set6chDownmix)(Downmix);
  394.         break;
  395.       }
  396.       case  APM_SET_2CHDOWNMIX:
  397.       {
  398.         SAMP(APM_2ch_MixDef) Downmix = SAMP_API_PARAM[0];
  399.         err = SAMP(APM_Set2chDownmix)(Downmix);
  400.         break;
  401.       }
  402.       case  APM_SET_SPEAKERS:
  403.       {
  404.         SAMP(APM_SpeakerDef) Speakers = SAMP_API_PARAM[0];
  405.         err = SAMP(APM_SetSpeakers)(Speakers);
  406.         break;
  407.       }
  408.       case  APM_SET_ATTENUATION:
  409.       {
  410.         SAMP(UInt16) Attenuation[8];
  411.         Attenuation[0] = SAMP_API_PARAM[0];
  412.         Attenuation[1] = SAMP_API_PARAM[1];
  413.         Attenuation[2] = SAMP_API_PARAM[2];
  414.         Attenuation[3] = SAMP_API_PARAM[3];
  415.         Attenuation[4] = SAMP_API_PARAM[4];
  416.         Attenuation[5] = SAMP_API_PARAM[5];
  417.         Attenuation[6] = SAMP_API_PARAM[6];
  418.         Attenuation[7] = SAMP_API_PARAM[7];
  419.         err = SAMP(APM_SetAttenuation)(Attenuation);
  420.         break;
  421.       }
  422.       case  APM_SET_DELAY:
  423.       {
  424.         SAMP(UInt32) Delay[6];
  425.         Delay[0] = SAMP_API_PARAM[0];
  426.         Delay[1] = SAMP_API_PARAM[1];
  427.         Delay[2] = SAMP_API_PARAM[2];
  428.         Delay[3] = SAMP_API_PARAM[3];
  429.         Delay[4] = SAMP_API_PARAM[4];
  430.         Delay[5] = SAMP_API_PARAM[5];
  432.         err = SAMP(APM_SetDelay)(Delay);
  433.         break;
  434.       }
  435.       case  APM_SET_FILTERMODE:
  436.       {
  437.         SAMP(APM_FilterModeDef) FilterMode = SAMP_API_PARAM[0];
  438.         err = SAMP(APM_SetFilterMode)(FilterMode);
  439.         break;
  440.       }
  441.       case  APM_SET_PCMUPSAMPLING:
  442.       {
  443.         SAMP(UInt8) Upsampling = SAMP_API_PARAM[0];
  444.         err = SAMP(APM_SetPcmUpsampling)(Upsampling);
  445.         break;
  446.       }
  447.       case  APM_SET_BASSFILTERS:
  448.       {
  449.         SAMP(APM_BassFrequencyDef) BassFrequency = SAMP_API_PARAM[0];
  450.         SAMP(APM_BassSlopeDef) BassSlope = SAMP_API_PARAM[1];
  451.         err = SAMP(APM_SetBassFilters)(BassFrequency, BassSlope);
  452.         break;
  453.       }
  454.       case  APM_SET_PIO:
  455.       {
  456.         SAMP(BitSet16) pio_bits = SAMP_API_PARAM[0];
  457.         err = SAMP(APM_SetPIO)(pio_bits);
  458.         break;
  459.       }
  460.      }
  462.      return err;
  463. }
  466. // *****************************************************************************
  467. // * Purpose          : handle the SAMP API function call event
  468. // * Input Parameters : err - error code return by API function call
  469. // * Return Value     : TRUE - API function call executed succesfuly
  470. // *    FALSE - API function call failed
  471. // * Description :
  472. // *****************************************************************************
  473. static SAMP(ErrCode) SAMP_SAMP_API_Handler(UINT32 param)
  474. {
  475.   SAMP(ErrCode) err = SAMP(ERR_OK);
  476.      switch(param)
  477.      {
  479.       case  SAMP_INIT:
  480.       {
  481.         err = SAMP(SAMP_Init)();
  482.         break;
  483.       }
  485.       case  SAMP_TERM:
  486.       {
  487.         err = SAMP(SAMP_Term)();
  488.         break;
  489.       }
  491.       case  SAMP_SACDDISCREC:
  492.       {
  493.         SAMP(Bool) *pSACD = SAMP_API_PARAM[0];
  494.         SAMP(Bool) *pHybrid = SAMP_API_PARAM[1];
  495.         err = SAMP(SAMP_SACDDiscRec)(pSACD, pHybrid);
  496.         break;
  497.       }
  498.       case  SAMP_ACTIVATE:
  499.       {
  500.         SAMP(Bool) discRecognised = SAMP_API_PARAM[0];
  501.         SAMP(SAMP_AreaInfoDef) *pST_Info = SAMP_API_PARAM[1];
  502.         SAMP(SAMP_AreaInfoDef) *pMC_Info = SAMP_API_PARAM[2];
  503.         SAMP(Bool) *pHybrid = SAMP_API_PARAM[3];
  504.         err = SAMP(SAMP_Activate)(discRecognised, pST_Info, pMC_Info, pHybrid);
  505.         break;
  506.       }
  507.       case  SAMP_DEACTIVATE:
  508.       {
  509.         err = SAMP(SAMP_Deactivate)();
  510.         break;
  511.       }
  512.       case  SAMP_REACTIVATE:
  513.       {
  514.         err = SAMP(SAMP_Reactivate)();
  515.         break;
  516.       }
  517.       case  SAMP_SUBSCRIBE:
  518.       {
  519.         SAMP(SAMP_CallbackDef) Callback = SAMP_API_PARAM[0];
  520.         SAMP(BitSet32) Events = SAMP_API_PARAM[1];
  521.         err = SAMP(SAMP_Subscribe)(Callback, Events);
  522.         break;
  523.       }
  526.      }
  528.      return err;
  529. }
  532. // *****************************************************************************
  533. // * Purpose          : handle the OSA API function call event
  534. // * Input Parameters : err - error code return by API function call
  535. // * Return Value     : TRUE - API function call executed succesfuly
  536. // *    FALSE - API function call failed
  537. // * Description :
  538. // *****************************************************************************
  539. static SAMP(ErrCode) SAMP_OSA_API_Handler(UINT32 param)
  540. {
  541.   SAMP(ErrCode) err = SAMP(ERR_OK);
  543.      switch(param)
  544.      {
  546.       case  OSA_TASK_CREATE:
  547.       {
  548.         PRIORITY Priority = (PRIORITY)SAMP_API_PARAM[0];
  549.         size_t Stacksize = (size_t)SAMP_API_PARAM[1];
  550.         FP Entry = SAMP_API_PARAM[2];
  551.         IDENT *Id = (IDENT *)SAMP_API_PARAM[3];
  552.         err = SAMP(OS_TaskCreate) (Priority, Stacksize, Entry, Id);
  553.         break;
  554.       }
  556.       case  OSA_TASK_DELETE:
  557.       {
  558.         IDENT Id = (IDENT)SAMP_API_PARAM[0];
  559.         err = SAMP(OS_TaskDelete) (Id);
  560.         break;
  561.       }
  563.       case  OSA_SEM_CREATE:
  564.       {
  565.         UNITS Units = (UNITS)SAMP_API_PARAM[0];
  566.         IDENT *Id = (IDENT *)SAMP_API_PARAM[1];
  567.         err = SAMP(OS_SemCreate) (Units, Id);
  568.         break;
  569.       }
  571.       case  OSA_SEM_DELETE:
  572.       {
  573.         IDENT Id = (IDENT)SAMP_API_PARAM[0];
  574.         err = SAMP(OS_SemDelete) (Id);
  575.         break;
  576.       }
  578.       case  OSA_SEM_V:
  579.       {
  580.         IDENT Id = (IDENT)SAMP_API_PARAM[0];
  581.         err = SAMP(OS_SemV) (Id);
  582.         break;
  583.       }
  585.      }
  587.      return err;
  589. }
  591. #endif
  593. #endif
  596. // *****************************************************************************
  597. // * Purpose          : handle the SDI API function call event
  598. // * Input Parameters : err - error code return by API function call
  599. // * Return Value     : TRUE - API function call executed succesfuly
  600. // *    FALSE - API function call failed
  601. // * Description :
  602. // *****************************************************************************
  603. static SAMP(ErrCode) SAMP_SDI_API_Handler(UINT32 param)
  604. {
  605. SAMP(ErrCode) err = SAMP(ERR_OK);
  607.      switch(param)
  608.      {
  610.       case SDI_SETAVAILABLECHARSETS:
  611.       {
  612.         SAMP(UInt8) nrOfCharSets = (SAMP(UInt8))SAMP_API_PARAM[0];
  613.         SAMP(UInt8) *pCharSetList = (SAMP(UInt8)*)SAMP_API_PARAM[1];
  614.         err = SAMP(SDI_SetAvailableCharSets)(nrOfCharSets, pCharSetList );
  615.         break;
  616.       }
  617.       case SDI_SETLANGPREF:
  618.       {
  619.         SAMP(UInt8) nrOfLanguages = (SAMP(UInt8))SAMP_API_PARAM[0];
  620.         SAMP(SDI_LanguageCodeDef) *pLanguageCodes = (SAMP(SDI_LanguageCodeDef) *)SAMP_API_PARAM[1];
  621.         err = SAMP(SDI_SetLanguagePreference)(nrOfLanguages, pLanguageCodes );
  622.         break;
  623.       }
  624.       case SDI_GETALBUMINFO:
  625.       {
  626.         SAMP(SDI_Album_Info) *pAlbumInfo = (SAMP(SDI_Album_Info) *)SAMP_API_PARAM[0];
  627.         err = SAMP(SDI_GetAlbumInfo)(pAlbumInfo );
  628.         break;
  629.       }
  630.       case SDI_GETALBUMTEXT:
  631.       {
  632.         SAMP(SDI_AlbumTextField) field = (SAMP(SDI_AlbumTextField))SAMP_API_PARAM[0];
  633.         SAMP(SDI_TextChannelType) type = (SAMP(SDI_TextChannelType))SAMP_API_PARAM[1];
  634.         SAMP(UInt32) bufferSize = (SAMP(UInt32))SAMP_API_PARAM[2];
  635.         void *pAlbumText = (void *)SAMP_API_PARAM[3];
  636.         SAMP(UInt8) *pCharSet = (SAMP(UInt8) *)SAMP_API_PARAM[4];
  637.         SAMP(SDI_LanguageCodeDef) *pLanguage = (SAMP(SDI_LanguageCodeDef) *)SAMP_API_PARAM[5];
  638.         err = SAMP(SDI_GetAlbumText)(field, type, bufferSize, pAlbumText, pCharSet, pLanguage );
  639.         break;
  640.       }
  641.       case SDI_GETDISCINFO:
  642.       {
  643.         SAMP(SDI_Disc_Info) *pDiscInfo = (SAMP(SDI_Disc_Info) *)SAMP_API_PARAM[0];
  644.         err = SAMP(SDI_GetDiscInfo)(pDiscInfo );
  645.         break;
  646.       }
  647.       case SDI_GETDISCTEXT:
  648.       {
  649.         SAMP(SDI_DiscTextField) field = (SAMP(SDI_DiscTextField))SAMP_API_PARAM[0];
  650.         SAMP(SDI_TextChannelType) type = SAMP_API_PARAM[1];
  651.         SAMP(UInt32) bufferSize = SAMP_API_PARAM[2];
  652.         void *pDiscText = (void *)SAMP_API_PARAM[3];
  653.         SAMP(UInt8) *pCharSet = (SAMP(UInt8) *)SAMP_API_PARAM[4];
  654.         SAMP(SDI_LanguageCodeDef) *pLanguage = (SAMP(SDI_LanguageCodeDef) *)SAMP_API_PARAM[5];
  655.         err = SAMP(SDI_GetDiscText)( field, type, bufferSize, pDiscText, pCharSet, pLanguage );
  656.         break;
  657.       }
  658.       case SDI_GETAREATEXT:
  659.       {
  660.         SAMP(SACD_Area) area = SAMP_API_PARAM[0];
  661.         SAMP(SDI_AreaTextField) field = SAMP_API_PARAM[1];
  662.         SAMP(SDI_TextChannelType) type = SAMP_API_PARAM[2];
  663.         SAMP(UInt32) bufferSize = SAMP_API_PARAM[3];
  664.         void *pAreaText = (void *)SAMP_API_PARAM[4];
  665.         SAMP(UInt8) *pCharSet = (SAMP(UInt8) *)SAMP_API_PARAM[5];
  666.         SAMP(SDI_LanguageCodeDef) *pLanguage = (SAMP(SDI_LanguageCodeDef) *)SAMP_API_PARAM[6];
  667.         err = SAMP(SDI_GetAreaText)( area, field, type, bufferSize, pAreaText, pCharSet, pLanguage );
  668.         break;
  669.       }
  670.       case SDI_GETTRACKINFO:
  671.       {
  672.         SAMP(SACD_Area) area = SAMP_API_PARAM[0];
  673.         SAMP(UInt8) trackNr = SAMP_API_PARAM[1];
  674.         SAMP(SDI_Track_Info) *pTrackInfo = (SAMP(SDI_Track_Info) *)SAMP_API_PARAM[2];
  675.         err = SAMP(SDI_GetTrackInfo)(area, trackNr, pTrackInfo );
  676.         break;
  677.       }
  678.       case SDI_GETTRACKTEXT:
  679.       {
  680.         SAMP(SACD_Area) area = SAMP_API_PARAM[0];
  681.         SAMP(UInt8) trackNr = SAMP_API_PARAM[1];
  682.         SAMP(SDI_TrackTextField) field = SAMP_API_PARAM[2];
  683.         SAMP(SDI_TextChannelType) type = SAMP_API_PARAM[3];
  684.         SAMP(UInt32) bufferSize = SAMP_API_PARAM[4];
  685.         void *pTrackText = (void *)SAMP_API_PARAM[5];
  686.         SAMP(UInt8) *pCharSet = (SAMP(UInt8) *)SAMP_API_PARAM[6];
  687.         SAMP(SDI_LanguageCodeDef) *pLanguage = (SAMP(SDI_LanguageCodeDef) *)SAMP_API_PARAM[7];
  688.         err = SAMP(SDI_GetTrackText)(area, trackNr, field, type, bufferSize, pTrackText, pCharSet, pLanguage );
  689.         break;
  690.       }
  691.       case SDI_GETNUMOFINDEX:
  692.       {
  693.         SAMP(SACD_Area) area = SAMP_API_PARAM[0];
  694.         SAMP(UInt8) track = SAMP_API_PARAM[1];
  695.         SAMP(UInt8) *pNrOfIndices = (SAMP(UInt8) *)SAMP_API_PARAM[2];
  696.         err = SAMP(SDI_GetNumberOfIndices)(area, track, pNrOfIndices );
  697.         break;
  698.       }
  699.       case SDI_GETDTCPINFO:
  700.       {
  701.         SAMP(UInt32) offset = SAMP_API_PARAM[0];
  702.         SAMP(UInt32) size = SAMP_API_PARAM[1];
  703.         void *pBuffer = (void *)SAMP_API_PARAM[2];
  704.         err = SAMP(SDI_GetDTCP_Info)(offset, size, pBuffer);
  705.         break;
  706.       }
  707.       case SDI_GETSPECVERSION:
  708.       {
  709.         SAMP(SDI_Spec_Version) *pSpecVersion = (SAMP(SDI_Spec_Version) *)SAMP_API_PARAM[0];
  710.         err = SAMP(SDI_GetSpecVersion)(pSpecVersion );
  711.         break;
  712.       }
  713.       case SDI_GETAREADATA:
  714.       {
  715.         SAMP(SACD_Area) area = SAMP_API_PARAM[0];
  716.         SAMP(SDI_Area_Data) *pAreaData = (SAMP(SDI_Area_Data) *)SAMP_API_PARAM[1];
  717.         err = SAMP(SDI_GetAreaData)(area, pAreaData );
  718.         break;
  719.       }
  720.      }
  722.    return err;
  723. }
  727. // *****************************************************************************
  728. // * Purpose          : API function call collector
  729. // * Input Parameters : param - IDE of the API function
  730. // * Return Value     : NA
  731. // * Description : Call API function according requeste parameter, after the
  732. // *                   API function call set error code in global variable and
  733. // *                  confirm the execution is finished to caller
  734. // *****************************************************************************
  735. void SAMP_API_Handler (UINT32 param)
  736. {
  737. SAMP(ErrCode) err = SAMP(ERR_OK);
  739.    char group = param >>8;
  741. #ifdef SAMP_READY
  743.    if(SDI_GROUP == group)
  744.    {
  745.      err = SAMP_SDI_API_Handler(param);
  747.    }
  749. #endif
  751. //for test only
  752. #ifdef TEST_HARNASS
  753. #ifdef SAMP_READY
  754.    else
  755.    if(NAV_GROUP == group)
  756.    {
  757.      err = SAMP_NAV_API_Handler(param);
  758.    }
  759.    else
  760.    if(SDM_GROUP == group)
  761.    {
  762.      err = SAMP_SDM_API_Handler(param);
  763.    }
  764.    else
  765.    if(APM_GROUP == group)
  766.    {
  767.      err = SAMP_APM_API_Handler(param);
  768.    }
  769.    else
  770.    if(SAMP_GROUP == group)
  771.    {
  772.      err = SAMP_SAMP_API_Handler(param);
  773.    }
  774.    else
  775.    if(OSA_GROUP == group)
  776.    {
  777.      err = SAMP_OSA_API_Handler(param);
  778.    }
  779. #endif
  781.    else
  782.    {
  784.      switch (param)
  785.      {
  786.    case SAMP_API_START:
  787.      err = SAMP_API_Start ();
  788.        break;
  790.       default:
  791.      dbg_printf (("The API command was not recognizedn"));
  792.        break;;
  793.      }
  794.    }
  796. #endif
  798.    SAMP_APICallAcknowledge (err);
  799. }
  802. #ifdef TEST_HARNASS
  804. // *****************************************************************************
  805. // * Purpose          : Start SAMP code by creating first task
  806. // * Input Parameters : NA
  807. // * Return Value     : error code of OS - schedular function
  808. // *****************************************************************************
  809. extern void task0 (void);
  810. extern IDENT tid0;
  811. SAMP(ErrCode) SAMP_API_Start (void)
  812. {
  813. return SAMP(OS_TaskCreate) (5,1500,task0,&tid0);
  814. }
  816. #endif
  818. #endif
  820. #endif // D_SUPPORT_SACD