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

源码开发语言/平台
当前位置：首页 > 源码/资料 > 多媒体 > DVD > 查看源码
av.c
资源名称：ST_5105DTV.rar　[点击查看]
上传用户：fy98168
上传日期：2015-06-26
资源大小：13771k
文件大小：20k
源码类别：

DVD

开发平台：

C/C++

av.c：源码内容
  1. #include <stdio.h>
  2. #include <string.h>
  4. #include "gendef.h"
  5. #include "dmx.h"
  6. #include "vid.h"
  7. #include "osp.h"
  8. #include "aud.h"
  9. #include "avslot.h"
  10. #include "errors.h"
  11. #include "evt.h"
  12. #include "av.h"
  13. #include "vtg.h"
  14. #include "denc.h"
  15. #include "timer.h"
  16. #include "stvid.h"
  17. #include "staudlt.h"
  18. #include "stpti_hal.h"
  19. #include "staud.h"
  20. #include "regevent.h"
  21. #include "vmix.h"
  22. #include "layer.h"
  23. #include "db.h"
  24. #define PLAYING 0
  25. #define STOPPED 1
  26. #define PAUSED 2
  28. static U16 attenuation_table[KB_AV_MAX_VOLUME] = 
  29. {
  30.     63, 62, 60, 58, 
  31.     54, 49, 44, 42,
  32.     38, 36, 30, 29, 
  33.     27, 25, 23, 22, 
  34.     20, 18, 17, 16,
  35.     15, 14, 13, 10, 
  36.     8,   6,  5,  4,  
  37.     3,   2,  1,  0
  38. };
  40. static UINT32 gnAvInitFlag = FALSE;
  41. static UINT32 gnAvVolume;
  42. static UINT32 gnAvMuteStatus;
  43. //added by whale 07/06/26 start
  44. static UINT32 gnAvMode;
  45. static UINT32 gnAvRatio;
  46. //added by whale 07/06/26 end
  47. static KB_DBTRACK gnAvChannel;
  49. static INT32  gnAvVideoEnabled;
  50. static INT32  gnAvVideoIframeEnabled;
  52. static UINT32 avTimer = KB_TIMER_INVALID_ID ;
  53. static void AVHandleTimer(void);
  54. static KB_AVPlayStartCallback s_ptCallback = NULL;
  55. static BOOL  s_bPlaySuccess = TRUE;
  57. static KB_AVPID gtAvCurrentPid;
  60. static INT32 nSavedLeft;
  61. static INT32 nSavedTop;
  62. static INT32 nSavedRight;
  63. static INT32 nSavedBottom;
  64. static BOOL gFullFlag;
  66. extern BOOL  SET_ENTRY_BROD_PutFullScreen_FLAGS;
  68. #define MP2A_SAMPLING_FREQUENCY 44100
  70. INT32 KB_AVInit(void)
  71. {
  72.     ST_ErrorCode_t ST_ErrorCode = ST_NO_ERROR;
  73.     
  74.     if (gnAvInitFlag == FALSE)
  75.     {   
  76.         ST_ErrorCode = AVSlotInit();    
  77.         if (ST_ErrorCode != ST_NO_ERROR)
  78.         {
  79.             Print("error init AVSlotInit n");
  80.             return RETFIAL1;
  81.         }
  82.         
  83.         ST_ErrorCode = VID_Setup();
  84.         if (ST_ErrorCode != ST_NO_ERROR)
  85.         {
  86.          Print("error init VID_Setup n");
  87.          return RETFIAL1;
  88.         }
  90.         ST_ErrorCode = AUD_Setup( SERVICE_MODE_DVB );
  91.         if (ST_ErrorCode != ST_NO_ERROR)
  92.         {
  93.          Print("error init AUD_Setup n");
  94.          return RETFIAL1;
  95.         }                
  97.         STAUD_SetStereoOutput(AUD_Handle, STAUD_STEREO_DUAL_LEFT);
  99. RegisterEvents();
  101.         gnAvVolume = 0;
  102.         gnAvMuteStatus = FALSE;
  103.         gnAvInitFlag = TRUE;
  104.         gnAvChannel = LEFT_TRACK;
  105.         gnAvVideoEnabled = FALSE;
  106.         gnAvVideoIframeEnabled = FALSE;
  107.         
  108.         memset(&gtAvCurrentPid, 0, sizeof(KB_AVPID));
  109.     if(avTimer == KB_TIMER_INVALID_ID )
  110.     {
  111.         avTimer = KB_TimerCreate(KB_TIMER_REPEAT , (KB_TIMER_FUNC_POINTER)AVHandleTimer,NULL);
  112.     }
  114.     }
  116.     gFullFlag = TRUE;    
  117. KB_AVGetWindow(&nSavedLeft, &nSavedTop, &nSavedRight, &nSavedBottom);    
  119. return RETOK;
  120. }
  122. INT32 KB_AVPlay(UINT32 nVideoPid, UINT32 nAudioPid, UINT32 nPcrPid)
  123. {
  124.     ST_ErrorCode_t ST_ErrorCode;
  125.     STAUD_StartParams_t AUDStartParams;
  126.     STVID_StartParams_t VIDStartParams;
  128.     KB_AVStop();    
  130.     if (nAudioPid > 0 && nAudioPid < 8191)
  131.     {
  132.         StartAud((UINT16)nAudioPid);    
  133.         gtAvCurrentPid.nAudioPid = nAudioPid;
  134.         
  135.         AUDStartParams.StreamContent     = STAUD_STREAM_CONTENT_MPEG2;
  136.         AUDStartParams.SamplingFrequency = MP2A_SAMPLING_FREQUENCY;
  137.         AUDStartParams.StreamType = STAUD_STREAM_TYPE_PES;
  139.         AUDStartParams.StreamID = STAUD_IGNORE_ID;
  141.         ST_ErrorCode = STAUD_Start(AUD_Handle, &AUDStartParams);
  142.         STTBX_Print(("%s,%d,Ignore)=%sn",
  143.         AUDStartParams.StreamContent == STAUD_STREAM_CONTENT_MPEG1 ? "MPEG1":"MPEG2",
  144.         AUDStartParams.SamplingFrequency, KB_ErrorGetText(ST_ErrorCode) ));
  147.         #ifdef DISABLE_AVSYNC_FOR_DVB
  148.             ST_ErrorCode = STAUD_DisableSynchronisation(AUD_Handle);
  149.             if ( ST_ErrorCode != ST_NO_ERROR )
  150.                 {
  151.                     STTBX_Print(("STAUD_DisableSyncronisation()=%sn", KB_ErrorGetText(ST_ErrorCode) ));
  152.                 }
  153.             #else
  154.                 ST_ErrorCode = STAUD_EnableSynchronisation(AUD_Handle);
  155.                 if ( ST_ErrorCode != ST_NO_ERROR )
  156.                 {
  157.                     STTBX_Print(("STAUD_EnableSyncronisation()=%sn", KB_ErrorGetText(ST_ErrorCode) ));
  158.                 }
  159.         #endif
  160.     }
  162.     if (nVideoPid > 0 && nVideoPid < 8191)
  163.     {
  164.         StartVid((UINT16)nVideoPid);
  165.         gtAvCurrentPid.nVideoPid = nVideoPid;
  166.         
  167.       #if defined(STVID_ERROR_RECOVERY_MODE_NONE)
  168.        {
  169.        ST_ErrorCode = STVID_SetErrorRecoveryMode(VID_Handle, STVID_ERROR_RECOVERY_NONE);
  170.        if ( ST_ErrorCode != ST_NO_ERROR )
  171.        {
  172.            STTBX_Print(("STVID_SetErrorRecoveryMode()Failed 0x%08x n", ST_ErrorCode ));
  173.        }
  174.        else
  175.        {
  176.            STTBX_Print(("STVID_SetErrorRecoveryMode()= STVID_ERROR_RECOVERY_NONE n" ));
  177.        }
  178.        }
  179.        #endif /* end of STVID_ERROR_RECOVERY_MODE_NONE */
  181.         VIDStartParams.RealTime      = TRUE;
  182.         VIDStartParams.UpdateDisplay = TRUE;
  183.         VIDStartParams.StreamID      = STVID_IGNORE_ID;
  184.         VIDStartParams.DecodeOnce    = FALSE;
  186.         VIDStartParams.StreamType    = STVID_STREAM_TYPE_PES;
  187.         VIDStartParams.BrdCstProfile = STVID_BROADCAST_DVB;
  189.         ST_ErrorCode = STVID_Start(VID_Handle, &VIDStartParams);
  190.         STTBX_Print(("STVID_Start %sn", KB_ErrorGetText(ST_ErrorCode) ));
  191.         
  192.         #ifdef DISABLE_AVSYNC_FOR_DVB
  193.             ST_ErrorCode = STVID_DisableSynchronisation(VID_Handle);
  194.             if ( ST_ErrorCode != ST_NO_ERROR )
  195.             {
  196.                  STTBX_Print(("STVID_DisableSyncronisation()=%sn", KB_ErrorGetText(ST_ErrorCode) ));
  197.             }
  198.         #else
  199.             ST_ErrorCode = STVID_EnableSynchronisation(VID_Handle);
  200.             if ( ST_ErrorCode != ST_NO_ERROR )
  201.             {
  202.                 STTBX_Print(("STVID_EnableSyncronisation()=%sn", KB_ErrorGetText(ST_ErrorCode) ));
  203.             }
  204.         #endif /* end of DISABLE_AVSYNC_FOR_DVB */
  206.     }
  208.     if (nPcrPid > 0 && nPcrPid < 8192)
  209.     {
  210.         StartPCR((UINT16)nPcrPid);  
  211.         gtAvCurrentPid.nPcrPid = nPcrPid;
  212.     }
  214.     s_bPlaySuccess = TRUE;
  215.     KB_TimerEnable(avTimer, 4000);
  217. return RETOK;
  218. }
  220. INT32 KB_AVStop(void)
  221. {
  222.     STAUD_Fade_t    Fade;
  223.     ST_ErrorCode_t error;
  224.     STVID_Stop_t    StopMode = STVID_STOP_NOW;
  225.     STVID_Freeze_t  Freeze;    
  227.     if (gtAvCurrentPid.nAudioPid != 0)
  228.     {
  229.         StopAud();   
  230.         gtAvCurrentPid.nAudioPid = 0;
  231.         
  232.         Fade.FadeType = STAUD_FADE_SOFT_MUTE;
  233.         error = STAUD_Stop(AUD_Handle, STAUD_STOP_NOW, &Fade);
  234.         if ( error != ST_NO_ERROR )
  235.         {
  236.             STTBX_Print(("STAUD_Stop=%sn", KB_ErrorGetText(error)));
  237.         }
  238.     }
  240.     if (gtAvCurrentPid.nVideoPid != 0)
  241.     {
  242.         StopVid();
  243.         gtAvCurrentPid.nVideoPid = 0;
  244.         
  245.         if (gnAvVideoIframeEnabled == FALSE)
  246.         {
  247.             Freeze.Field = STVID_FREEZE_FIELD_TOP;
  248.             Freeze.Mode = STVID_FREEZE_MODE_NO_FLICKER;    
  250.             DBGPrint("gnAvVideoIframeEnabled = %dn", (int)gnAvVideoIframeEnabled);
  251.             
  252.             STVID_DisableOutputWindow(VID_ViewPortHandle);
  253.             gnAvVideoEnabled = FALSE;
  254.             
  255.             error = STVID_Stop(VID_Handle, StopMode, &Freeze);
  256.             if ( error != ST_NO_ERROR )
  257.             {
  258.                 STTBX_Print(("STVID_Stop=%sn", KB_ErrorGetText(error)));
  259.             }        
  260.         }
  261.     }
  263.     if (gtAvCurrentPid.nPcrPid != 0)
  264.     {
  265.         StopPCR();
  266.         gtAvCurrentPid.nPcrPid = 0;
  267.     }
  268.     
  269.     KB_TimerDisable(avTimer);
  270.     
  271. return RETOK;
  272. }
  274. INT32 AVStop_A(void)
  275. {
  276.     STAUD_Fade_t    Fade;
  277.     ST_ErrorCode_t error;
  278.     //STVID_Stop_t    StopMode = STVID_STOP_NOW;
  279.     //STVID_Freeze_t  Freeze;    
  281.     if (gtAvCurrentPid.nAudioPid != 0)
  282.     {
  283.         gtAvCurrentPid.nAudioPid = 0;
  284.         
  285.         Fade.FadeType = STAUD_FADE_SOFT_MUTE;
  286.         error = STAUD_Stop(AUD_Handle, STAUD_STOP_NOW, &Fade);
  287.     }
  289.     if (gtAvCurrentPid.nPcrPid != 0)
  290.     {
  291.         StopPCR();
  292.         gtAvCurrentPid.nPcrPid = 0;
  293.     }
  294.     
  295.     KB_TimerDisable(avTimer);
  296. return RETOK;
  297. }
  299. INT32 AVStop_V(void)
  300. {
  301.     //STAUD_Fade_t    Fade;
  302.     ST_ErrorCode_t error;
  303.     STVID_Stop_t    StopMode = STVID_STOP_NOW;
  304.     STVID_Freeze_t  Freeze;    
  307.     if (gtAvCurrentPid.nVideoPid != 0)
  308.     {
  309.         StopVid();
  310.         gtAvCurrentPid.nVideoPid = 0;
  311.         
  312.         if (gnAvVideoIframeEnabled == FALSE)
  313.         {
  314.             Freeze.Field = STVID_FREEZE_FIELD_TOP;
  315.             Freeze.Mode = STVID_FREEZE_MODE_NO_FLICKER;    
  317.             STVID_DisableOutputWindow(VID_ViewPortHandle);
  318.             gnAvVideoEnabled = FALSE;
  319.             
  320.             error = STVID_Stop(VID_Handle, StopMode, &Freeze);
  321.         }
  322.     }
  324.     if (gtAvCurrentPid.nPcrPid != 0)
  325.     {
  326.         StopPCR();
  327.         gtAvCurrentPid.nPcrPid = 0;
  328.     }
  329.     
  330.     KB_TimerDisable(avTimer);
  332. return RETOK;
  333. }
  335. INT32 KB_AVPause(void)
  336. {       
  337.     STAUD_Fade_t   Fade;
  338.     STVID_Freeze_t Freeze;    
  339.     ST_ErrorCode_t ST_ErrorCode;
  340.     
  341.     Fade.FadeType = STAUD_FADE_SOFT_MUTE;
  342.     ST_ErrorCode = STAUD_Pause(AUD_Handle, &Fade);
  343.     if (ST_ErrorCode != ST_NO_ERROR)
  344.     {
  345.         STTBX_Print(("STAUD_Pause()=%sn", KB_ErrorGetText(ST_ErrorCode) ));
  346.     }
  348.     Freeze.Field = STVID_FREEZE_FIELD_TOP;
  349.     Freeze.Mode = STVID_FREEZE_MODE_NO_FLICKER;    
  350.     ST_ErrorCode = STVID_Pause(VID_Handle, &Freeze);
  351.     if (ST_ErrorCode != ST_NO_ERROR)
  352.     {
  353.         STTBX_Print(("STVID_Pause()=%sn", KB_ErrorGetText(ST_ErrorCode) ));
  354.     }
  355.     
  356. return RETOK;
  357. }
  358. INT32 KB_AVSetWindow(INT32 nLeft, INT32 nTop, INT32 nRight, INT32 nBottom)
  359. {
  360. ST_ErrorCode_t ErrCode = ST_NO_ERROR;
  361.     STGXOBJ_Rectangle_t OutputRectangle;
  362.     BOOL AutoMode;
  363.     STVID_WindowParams_t WinParams;
  365.     if (nLeft == 0 && nTop == 0 && nRight == 720 && nBottom == 576)
  366.         gFullFlag = TRUE;
  367.     else  
  368.     gFullFlag = FALSE;
  370.        nSavedLeft   = nLeft;
  371.      nSavedTop    = nTop;
  372.      nSavedRight  = nRight;
  373.      nSavedBottom = nBottom;
  375.     if (nLeft % 2 == 0)
  376.     {
  377.         OutputRectangle.PositionX = (S32)nLeft;
  378.     }
  379.     else
  380.     {
  381.         OutputRectangle.PositionX = (S32)nLeft + 1;
  382.     }
  383.     if (nTop % 2 == 0)
  384.     {
  385.         OutputRectangle.PositionY = (S32)nTop;
  386.     }
  387.     else
  388.     {
  389.         OutputRectangle.PositionY = (S32)nTop + 1;
  390.     }
  391.     OutputRectangle.Width     = (U32)(nRight - nLeft);
  392.     OutputRectangle.Height    = (U32)(nBottom - nTop);
  393.     if ( OutputRectangle.Width == 0 )
  394.          OutputRectangle.Width = g_KB_VtgModeParams.ActiveAreaWidth;
  395.     if ( OutputRectangle.Height == 0 )
  396.             OutputRectangle.Height = g_KB_VtgModeParams.ActiveAreaHeight;
  397.     
  398.     STVID_GetOutputWindowMode(VID_ViewPortHandle, &AutoMode, &WinParams);
  399.     STVID_SetOutputWindowMode(VID_ViewPortHandle, FALSE, &WinParams);
  401.     ErrCode = STVID_SetIOWindows(VID_ViewPortHandle, 0, 0, 0, 0,
  402.                                  OutputRectangle.PositionX,
  403.                                  OutputRectangle.PositionY,
  404.                                  OutputRectangle.Width,
  405.                                  OutputRectangle.Height);
  407.     if ( ErrCode != ST_NO_ERROR )
  408.     {
  409.         STTBX_Print(("STVID_SetIOWindows()=%sn", KB_ErrorGetText(ErrCode)));
  410. return RETFIAL1;
  411.     }
  413. return RETOK;
  415. }
  417. INT32 KB_AVGetWindow(INT32 *pLeft, INT32 *pTop, INT32 *pRight, INT32 *pBottom)
  418. {   
  419. ST_ErrorCode_t    ErrCode;
  420.     S32 InputWinPositionX;
  421.     S32 InputWinPositionY;
  422.     U32 InputWinWidth;
  423.     U32 InputWinHeight;
  424.     S32 OutputWinPositionX;
  425.     S32 OutputWinPositionY;
  426.     U32 OutputWinWidth;
  427.     U32 OutputWinHeight;
  429. if( (pLeft == NULL) || (pTop == NULL)
  430. || (pRight == NULL) || (pBottom == NULL) ) return RETFAIL3;
  432.     if (( ErrCode = STVID_GetIOWindows( VID_ViewPortHandle,
  433.                                         &InputWinPositionX,  &InputWinPositionY,
  434.                                         &InputWinWidth,      &InputWinHeight,
  435.                                         &OutputWinPositionX, &OutputWinPositionY,
  436.                                         &OutputWinWidth,     &OutputWinHeight )) != ST_NO_ERROR)
  437.     {
  438.         STTBX_Print(("STVID_GetIOWindows()=%sn", KB_ErrorGetText(ErrCode)));
  439. return RETFIAL1;
  440.     }
  442. *pLeft = (INT32)OutputWinPositionX;
  443. *pTop = (INT32)OutputWinPositionY;
  444. *pRight = (INT32)(OutputWinPositionX + (INT32)OutputWinWidth);
  445. *pBottom= (INT32)(OutputWinPositionY + (INT32)OutputWinHeight);
  447. return RETOK;
  448. }
  450. INT32 KB_AVChangeWindow(BOOL bFull)
  451. {
  452. if(bFull)
  453. KB_AVSetWindow(0,0,720,576);
  454. else
  455. KB_AVSetWindow(nSavedLeft,nSavedTop,nSavedRight,nSavedBottom);
  457.        gFullFlag = bFull;
  459. return RETOK;
  461. }
  463. BOOL  KB_AVGetWindowFlag(void)
  464. {
  465. return gFullFlag;
  466. }
  468. INT32 KB_AVSetMute(BOOL bisMute)
  469. {
  470.     ST_ErrorCode_t ST_ErrorCode;
  472.     gnAvMuteStatus = bisMute;
  473. if(bisMute)
  474.     ST_ErrorCode = STAUD_Mute(AUD_Handle, TRUE, TRUE);
  475. else
  476. ST_ErrorCode = STAUD_Mute(AUD_Handle, FALSE, FALSE);
  477.     if ( ST_ErrorCode != ST_NO_ERROR )
  478.     {
  479.         STTBX_Print(("STAUD_Mute(TRUE)=%sn", KB_ErrorGetText(ST_ErrorCode) ));
  480.     }    
  481.     
  482. return RETOK;
  483. }
  485. INT32 KB_AVGetMuteFlag(void)
  486. {
  487.     return gnAvMuteStatus;
  488. }
  490. INT32 KB_AVSetPrgTrack(KB_DBTRACK nTrack)
  491. {
  492.     STAUD_Stereo_t nMode;
  493.     
  494.     if (nTrack > STEREO_TRACK)
  495.     {        
  496.         return RETFAIL3;
  497.     }
  498.     else
  499.     {
  500.         if (gnAvChannel == nTrack)
  501.         {
  502.             return RETOK;           
  504.         }
  505.         
  506.         switch (nTrack)
  507.         {
  508.         case LEFT_TRACK:
  509.             nMode = STAUD_STEREO_DUAL_LEFT;
  510.             break;
  511.             
  512.         case RIGHT_TRACK:
  513.             nMode = STAUD_STEREO_DUAL_RIGHT;
  514.             break;
  516.         case STEREO_TRACK:
  517.             nMode = STAUD_STEREO_STEREO;
  518.             break;
  520.         default:
  521.             nMode = STAUD_STEREO_DUAL_LEFT;
  522.             break;
  523.         }
  524.         
  525.         STAUD_SetStereoOutput(AUD_Handle, nMode);
  526.         gnAvChannel = nTrack;
  527.     return RETOK;
  528.     }
  529. }
  531. KB_DBTRACK KB_AVGetTrack(void)
  532. {
  533. return gnAvChannel;
  534. }
  536. INT32 KB_AVSetVolume(INT32 nVolume)
  537. {
  538.     STAUD_Attenuation_t Attenuation;
  539.     U16 left_volume, right_volume;
  540.     
  541.     if (nVolume < 0 || nVolume > KB_AV_MAX_VOLUME - 1)
  542.     {
  543.         return RETFAIL3;
  544.     }
  546.     gnAvVolume = nVolume;
  547.     memset(&Attenuation, 0, sizeof(STAUD_Attenuation_t));
  548.     
  549.     left_volume = right_volume = (U16)nVolume;
  550.     Attenuation.Left = attenuation_table[left_volume];
  551.     Attenuation.Right = attenuation_table[right_volume];
  552.     STAUD_SetAttenuation(AUD_Handle, Attenuation);
  553.     
  554. return RETOK;
  555. }
  557. INT32 KB_AVGetVolume(void)
  558. {
  559. return gnAvVolume;
  560. }
  562. void AVHandleNewVideoFrame(STEVT_CallReason_t Reason, 
  563.                              STEVT_EventConstant_t Event, 
  564.                              const void *EventData)
  565. {
  566.     ST_ErrorCode_t ErrCode;
  567.     STVID_PictureInfos_t PictureInfo;
  568.     static U32 FrameRate = 25000;
  570.     ErrCode = ST_NO_ERROR;
  572. if((Event == STVID_NEW_PICTURE_TO_BE_DISPLAYED_EVT) && gnAvVideoEnabled == FALSE)
  573.    {        
  574.         PictureInfo = *((STVID_PictureInfos_t*) EventData);
  575.         STTBX_Print(("FRAME_RATE = %dn", PictureInfo.VideoParams.FrameRate));
  576. if(FrameRate != PictureInfo.VideoParams.FrameRate)
  577. {
  578. STTBX_Print(("New FRAME_RATE detected = %dn", PictureInfo.VideoParams.FrameRate));
  579. FrameRate = PictureInfo.VideoParams.FrameRate;
  580. }
  582. STVID_EnableOutputWindow(VID_ViewPortHandle);  
  583.         gnAvVideoEnabled = TRUE;
  584.     }
  585.     
  586.     return;
  587. }
  589. static void AVHandleTimer(void)
  590. {
  591. static U32 oldVideoCount = 0;
  592. static U32 oldAudioCount = 0;
  594. BOOL bVideo = TRUE;
  595. if(oldVideoCount == VideoEvent_STVID_NEW_PICTURE_TO_BE_DISPLAYED_EVT_Count)
  596. {
  597. bVideo = FALSE;
  598. }
  599. else
  600. {
  601. oldVideoCount = VideoEvent_STVID_NEW_PICTURE_TO_BE_DISPLAYED_EVT_Count;
  602. }
  604. if(oldAudioCount == AudioEvent_STAUD_NEW_FRAME_EVT_Count)
  605. {
  606. if(!bVideo)
  607. {
  608. s_bPlaySuccess = FALSE;
  609. if(s_ptCallback != NULL)
  610. {
  611. s_ptCallback(FALSE, 0, 0, 0);
  612. }
  613. }
  614. }
  615. else
  616. {
  617. oldAudioCount = AudioEvent_STAUD_NEW_FRAME_EVT_Count;
  619. if(!s_bPlaySuccess)
  620. {
  621. s_bPlaySuccess = TRUE;
  622. if(s_ptCallback != NULL)
  623. {
  624. s_ptCallback(TRUE, 0, 0, 0);
  625. }
  626. }
  627. }
  629. }
  632. BOOL KB_AVGetIFrameFlag(void)
  633. {
  634.     return (BOOL)gnAvVideoIframeEnabled;
  635. }
  637. INT32 KB_AVPlayIFrame(UINT8 *pInData, INT32 nDataSize)
  638. {
  639.     Switch2Iframe(pInData, (int)nDataSize);
  640.     gnAvVideoIframeEnabled = TRUE;
  641.     return RETOK;
  642. }
  644. INT32 KB_AVStopIFrame(void)
  645. {
  646.     Switch2Live();
  647.     gnAvVideoEnabled = FALSE;
  648.     gnAvVideoIframeEnabled = FALSE;
  649.     return RETOK;
  650. }
  651. KB_AVPlayStartCallback KB_AVHandlePlayState(KB_AVPlayStartCallback ptCallback)
  652. {
  653. KB_AVPlayStartCallback oldCallBack = s_ptCallback;
  654. s_ptCallback = ptCallback;
  656. return oldCallBack;
  657. }
  658. #if 0
  659. extern STVID_ViewPortHandle_t  VID_ViewPortHandle_Multiple[VIDEO_USED]; /* j_vid.c */
  661. int KB_AVSetTVAspectRatioAndMatchMode(KB_AVAspectRatio nAspectRatio, 
  662.                             STVID_DisplayAspectRatioConversion_t nMatchMode)
  663. {
  664. STVMIX_ScreenParams_t ScreenParams;
  665. STLAYER_LayerParams_t LayerParams;
  666. STVID_DisplayAspectRatioConversion_t STVID_darc = STVID_DISPLAY_AR_CONVERSION_IGNORE;
  667.     STVID_WindowParams_t  WindowParams;
  668. ST_ErrorCode_t        ErrCode = ST_NO_ERROR;
  670.     WindowParams.Size  = STVID_WIN_SIZE_DONT_CARE;
  671.     WindowParams.Align = STVID_WIN_ALIGN_VCENTRE_HCENTRE;
  673.     ErrCode  = STLAYER_GetLayerParams(g_KB_LayerHandle[LAYER_VIDEO], &LayerParams);
  674.     ErrCode |= STVMIX_GetScreenParams(g_KB_VmixHandle, &ScreenParams);
  676. if (ErrCode == ST_NO_ERROR)
  677. {
  678. switch (nAspectRatio)
  679. {
  680. case KB_AV_ASPECT_RATIO_16TO9:
  681.             LayerParams.AspectRatio  = STGXOBJ_ASPECT_RATIO_16TO9;
  682.             ScreenParams.AspectRatio = STGXOBJ_ASPECT_RATIO_16TO9;
  683. break;
  685. case KB_AV_ASPECT_RATIO_4TO3:
  686.         LayerParams.AspectRatio  = STGXOBJ_ASPECT_RATIO_4TO3;
  687.         ScreenParams.AspectRatio = STGXOBJ_ASPECT_RATIO_4TO3;
  688. break;
  690. default:
  691.     ErrCode = ST_ERROR_BAD_PARAMETER;
  692. break;
  693. }
  694. }
  695.         
  696. if (ErrCode == ST_NO_ERROR)
  697. {
  698. ErrCode = STLAYER_SetLayerParams(g_KB_LayerHandle[LAYER_VIDEO], &LayerParams);
  699. }
  701. if (ErrCode == ST_NO_ERROR)
  702. {
  703. ErrCode = STVMIX_SetScreenParams(g_KB_VmixHandle, &ScreenParams);
  704. }
  706. if (ErrCode != ST_NO_ERROR)
  707. {
  708. return RETFIAL1;
  709. }
  710.  
  711.     STVID_darc = nMatchMode;
  712.  
  713.     
  714.     ErrCode = STVID_SetDisplayAspectRatioConversion(VID_ViewPortHandle_Multiple[VIDEO_USED-1], STVID_darc);
  715.     if (ErrCode != ST_NO_ERROR)
  716.     {
  717.         STTBX_Print(("[VID]: SetDisplayAspectRatioConversion()=%d err=0x%x n",
  718.              KB_ErrorGetText(ErrCode), ErrCode));
  719.     }
  720.  
  721.     STVID_SetOutputWindowMode(VID_ViewPortHandle_Multiple[VIDEO_USED-1], TRUE, &WindowParams );
  722.  
  723.     return RETOK;
  724. }
  725. #else
  726. int KB_AVSetAspectRatio(KB_AVAspectRatio nAspectRatio)
  727. {
  728. ST_ErrorCode_t ErrCode = ST_NO_ERROR;
  729. //STGXOBJ_AspectRatio_t *nRatio;
  730. if (gnAvRatio != nAspectRatio)
  731. {
  732. gnAvRatio = nAspectRatio;
  733. switch (nAspectRatio)
  734. {
  735. case KB_AV_ASPECT_RATIO_16TO9:
  736. ErrCode = KB_VmixSetAspectRatio(STGXOBJ_ASPECT_RATIO_16TO9);
  737. break;
  738. case KB_AV_ASPECT_RATIO_4TO3:
  739. ErrCode = KB_VmixSetAspectRatio(STGXOBJ_ASPECT_RATIO_4TO3);
  740. break;
  741. default:
  742.      ErrCode = ST_ERROR_BAD_PARAMETER;
  743. break;
  744. }
  745. }
  747. if (ErrCode != ST_NO_ERROR)
  748. {
  749. Print("KB_AVSetAspectRatio=%sn", KB_ErrorGetText(ErrCode));
  750. return RETFIAL1;
  751. }
  752.         KB_DBSaveVideoAspectRatio((UINT8)nAspectRatio);
  753.      return RETOK;
  754. }
  755. #endif
  756. int KB_AVSetMode(KB_AVVideoDisplayMode nMode)
  757. {
  758. ST_ErrorCode_t ErrCode = ST_NO_ERROR;
  759. if (gnAvMode != nMode)
  760. {
  761. gnAvMode = nMode;
  762. switch(nMode)
  763. {
  764. case KB_AV_VIDEO_DISPLAY_PAL:
  765. ErrCode = KB_DENCSetMode( STDENC_MODE_PALBDGHI );
  766. ErrCode |= KB_VtgSetMode( STDENC_MODE_PALBDGHI );
  767. break;
  768. case KB_AV_VIDEO_DISPLAY_NTSC:
  769. ErrCode = KB_DENCSetMode( STDENC_MODE_NTSCM );
  770. ErrCode |= KB_VtgSetMode( STDENC_MODE_NTSCM );
  771. break;
  772. case KB_AV_VIDEO_DISPLAY_SECAM:
  773. ErrCode = KB_DENCSetMode( STDENC_MODE_SECAM );
  774. ErrCode |= KB_VtgSetMode( STDENC_MODE_SECAM );
  775. break;
  776. default:
  777. ErrCode = ST_ERROR_BAD_PARAMETER;
  778. break;
  779. }
  780. }
  782. if (ErrCode != ST_NO_ERROR)
  783. {
  784. Print("KB_AVSetMode=%sn", KB_ErrorGetText(ErrCode));
  785. return RETFIAL1;
  786. }
  787.  
  788. //added by yyj 2007.6.29
  789. KB_DBSaveVideoDispMode((UINT8)nMode);
  792.      return RETOK;
  793. }
  794. /* EOF */