mediaplayer.c

BREW SDK 3.1。BREW应用程序的开发包。

      // Initialize ProgCtl
      pme->m_ProgCtl.m_pIShell = pme->m_pIShell;
      pme->m_ProgCtl.m_pIDisplay = pme->m_pIDisplay;
      if (!CProgCtl_Init(&pme->m_ProgCtl, &rectProg))
         MP_WINERR_RETURN(pme);

      MP_AddMenuItem(pme->m_pPlayerMenu, 0, NULL, IDB_PLAY,     IDM_PM_PLAY,   0);
      MP_AddMenuItem(pme->m_pPlayerMenu, 0, NULL, IDB_STOP,     IDM_PM_STOP,   0);
      MP_AddMenuItem(pme->m_pPlayerMenu, 0, NULL, IDB_FULLSCRN, IDM_PM_FULLSCRN, 0);
      MP_AddMenuItem(pme->m_pPlayerMenu, 0, NULL, IDB_REWIND,   IDM_PM_REWIND, 0);
      MP_AddMenuItem(pme->m_pPlayerMenu, 0, NULL, IDB_PAUSE,    IDM_PM_PAUSE,  0);
      MP_AddMenuItem(pme->m_pPlayerMenu, 0, NULL, IDB_FF,       IDM_PM_FF,     0);
      if (pme->m_eWin == MPPW_RECORD)
         MP_AddMenuItem(pme->m_pPlayerMenu, 0, NULL, IDB_RECORD, IDM_PM_RECORD, 0);
      MP_AddMenuItem(pme->m_pPlayerMenu,    0, NULL, IDB_UP,     IDM_PM_UP,     0);
      MP_AddMenuItem(pme->m_pPlayerMenu,    0, NULL, IDB_DOWN,   IDM_PM_DOWN,   0);
   }

   return (IWindow *)pme;
}

/*===========================================================================
   This function deletes the player window.
===========================================================================*/
static void CPlayerWin_Delete(IWindow * po)
{
   CPlayerWin *   pme = (CPlayerWin *)po;

   MP_RELEASEIF(pme->m_pTitle);
   MP_RELEASEIF(pme->m_pIdleImage);
   MP_RELEASEIF(pme->m_pPlayerMenu);

   // Release memory for file name allocated in CMediaPlayer
   FREEIF(pme->m_pszFile);

   if (CPlayerWin_IsMedia(pme))
   {
      MP_RELEASEIF(pme->m_pMedia);

      CProgCtl_Release(&pme->m_ProgCtl);

      if (pme->m_bProgTimer)
         ISHELL_CancelTimer(pme->m_pIShell, (PFNNOTIFY)CPlayerWin_ProgTimerNotify, pme);
   }
   else if (CPlayerWin_IsImage(pme))
   {
      MP_RELEASEIF(pme->m_pImage);
      MP_RELEASEIF(pme->m_pImageCtl);
   }

   FREE(pme);
}

/*===========================================================================
   This function enables/disables the player window.
===========================================================================*/
static void CPlayerWin_Enable(IWindow * po, boolean bEnable)
{
   CPlayerWin *   pme = (CPlayerWin *)po;
   boolean        bActive;

   if (!CWindow_ProcessEnable(po, bEnable))
      return;

   bActive = pme->m_bActive;

   ISTATIC_SetActive(pme->m_pTitle, bActive);
   IMENUCTL_SetActive(pme->m_pPlayerMenu, bActive);
   if (CPlayerWin_IsImage(pme))
      IIMAGECTL_SetActive(pme->m_pImageCtl, bActive);

   if (!pme->m_bActive)
   {
      IIMAGE_Stop(pme->m_pIdleImage);
      if (CPlayerWin_IsMedia(pme) && pme->m_pMedia)
            IMEDIA_Stop(pme->m_pMedia);
   }
   else
   {
      IMENUCTL_SetSel(pme->m_pPlayerMenu, (uint16) (pme->m_eWin == MPPW_PLAY ? IDM_PM_PLAY : IDM_PM_RECORD));
   }
}

/*===========================================================================
   This function redraws player window.
   If the full screen mode is on, then
   (1) if playback is not ongoing, then it paints the screen with black.
   (2) if image is being displayed, then redraws the image.
===========================================================================*/
static void CPlayerWin_Redraw(IWindow * po)
{
   CPlayerWin *   pme = (CPlayerWin *)po;
   char *         pszFile = pme->m_pszFile;
   AEERect        rect;

   if (!pme->m_bActive)
      return;

   if (MP_ISFULLSCRN(pme))
   {
      if (!pme->m_bPlayRec)
      {
         IDISPLAY_FillRect(pme->m_pIDisplay, NULL, RGB_BLACK);
         IDISPLAY_Update(pme->m_pIDisplay);
      }
      else if (CPlayerWin_IsImage(pme))
      {
         IDISPLAY_ClearScreen(pme->m_pIDisplay);
         IIMAGECTL_Redraw(pme->m_pImageCtl);
         IDISPLAY_Update(pme->m_pIDisplay);
      }

      return;
   }

   IDISPLAY_ClearScreen(pme->m_pIDisplay);

   // Header
   MP_DRAWHEADER(pme);

   // File name (title) text
   if (pszFile)
   {
      STRTOWSTR(MP_GetFileName(pszFile), pme->m_szText, sizeof(pme->m_szText));
      MP_FitStaticText(pme->m_pIDisplay, pme->m_pTitle, AEE_FONT_NORMAL, pme->m_szText);
      ISTATIC_Redraw(pme->m_pTitle);
   }

   // Draw the line below text.
   ISTATIC_GetRect(pme->m_pTitle, &rect);
   rect.y += rect.dy - 1; rect.dy = 1;
   MP_FrameRect(pme->m_pIDisplay, &rect);

   // SoftKey
   IMENUCTL_Redraw(pme->m_pPlayerMenu);

   if (CPlayerWin_IsMedia(pme))
   {
      // Video/Image
      if (!pme->m_bPlayRec)
         MP_DrawImage(pme->m_pIdleImage, &pme->m_rectImage, TRUE);

      // Progress bar...
      CPlayerWin_UpdateProgCtl(pme, 0, 0, 0);
   }
   else if (CPlayerWin_IsImage(pme))
   {
      IIMAGECTL_Redraw(pme->m_pImageCtl);
      IDISPLAY_Update(pme->m_pIDisplay);
   }
}

/*===========================================================================
   This function handles the events routed to the player window.
   If the event is
   (1) CLR or OK from error dialog: 
       (a) If app is in plugin mode, it is closed.
       (b) If media playback is on, then file list window is opened
       (c) If recording is on, then main window is opened

   (2) AVK_0 or EVT_COMMAND(IDM_PM_FULLSCRN): Full screen is toggled
   (3) EVT_CREATEMEDIA: Media is created using AEEMediaUtil_CreateMedia()
   (4) EVT_CREATEMEDIA_QCP: IMediaQCP is created and its media data is set 
       to put it in Ready state.
   (5) EVT_COMMAND: processes the menu commands.
   (6) EVT_KEY: routed appropriately to the controls.
===========================================================================*/
static boolean CPlayerWin_HandleEvent(IWindow * po, AEEEvent eCode, uint16 wParam, uint32 dwParam)
{
   CPlayerWin *   pme = (CPlayerWin *)po;
   boolean        bRet = TRUE;

   // Process CLR or OK from error dlg
   if (MP_ISCLR(eCode) || MP_ISCMD(eCode, IDS_OK))
   {
      // Stop the app if it is in plugin mode.
      if (MP_ISPLUGIN(pme))
         ISHELL_CloseApplet(pme->m_pIShell, FALSE);
      else
      {
         if (pme->m_eWin == MPPW_PLAY || pme->m_eWin == MPPW_IMAGE)
            CMediaPlayer_SetWindow(pme->m_pOwner, MPW_FILELIST, 0);
         else if (pme->m_eWin == MPPW_RECORD)
            CMediaPlayer_SetWindow(pme->m_pOwner, MPW_MAIN, 0);
      }

      return TRUE;
   }

   // Process EVT_KEY...
   if (MP_ISEVTKEY(eCode))
   {
      if (wParam == AVK_0)
         CPlayerWin_FullScreen(pme, (boolean)!pme->m_bFullScreen, FALSE);
      else if (CPlayerWin_IsMedia(pme))
         return IMENUCTL_HandleEvent(pme->m_pPlayerMenu, eCode, wParam, dwParam);
      else if (CPlayerWin_IsImage(pme))
      {
         if (wParam !=  AVK_SELECT)
            return IIMAGECTL_HandleEvent(pme->m_pImageCtl, eCode, wParam, dwParam);
         else
            return IMENUCTL_HandleEvent(pme->m_pPlayerMenu, eCode, wParam, dwParam);
      }

      return TRUE;
   }

   // Process create media events...
   if (eCode == EVT_CREATEMEDIA || eCode == EVT_CREATEMEDIA_QCP)
   {
      int   nRet;

      if (eCode == EVT_CREATEMEDIA)
         nRet = AEEMediaUtil_CreateMedia(pme->m_pIShell, &pme->m_md, &pme->m_pMedia);
      else
      {
         nRet = ISHELL_CreateInstance(pme->m_pIShell, AEECLSID_MEDIAQCP, (void **)&pme->m_pMedia);
         if (nRet == SUCCESS)
            nRet = IMEDIA_SetMediaData(pme->m_pMedia, &pme->m_md);
      }

      if (SUCCESS != nRet)
         MP_ErrorDlg(pme->m_pOwner, IDS_ERR_CREATEMEDIA);
      else if (SUCCESS != IMEDIA_RegisterNotify(pme->m_pMedia, CPlayerWin_MediaNotify, pme))
         MP_ErrorDlg(pme->m_pOwner, IDS_ERR_MEDIA);
      else
      {
         uint32   dwCaps;

         IMEDIA_GetMediaParm(pme->m_pMedia, MM_PARM_CAPS, (int32 *)&dwCaps, 0);
         pme->m_bImage = (dwCaps & MM_CAPS_VIDEO) ? TRUE : FALSE;
         if (!pme->m_bImage)
            IMENUCTL_DeleteItem(pme->m_pPlayerMenu, IDM_PM_FULLSCRN);
         else
            IMEDIA_SetRect(pme->m_pMedia, &pme->m_rectImage, NULL);

         CMediaPlayer_Redraw(pme->m_pOwner, TRUE);
      }

      return TRUE;
   }

   // If this event is not EVT_COMMAND, then return...
   if (!MP_ISEVTCMD(eCode))
      return FALSE;

   if ( (CPlayerWin_IsMedia(pme) && !pme->m_pMedia) ||
        (CPlayerWin_IsImage(pme) && !pme->m_pImageCtl) )
      return TRUE;

   // Process EVT_COMMAND...
   switch (wParam)
   {
      case IDM_PM_PLAY:
         if (CPlayerWin_IsPause(pme))
            IMEDIA_Resume(pme->m_pMedia);
         else if (SUCCESS != IMEDIA_GetTotalTime(pme->m_pMedia))
         {
            if (AEE_SUCCESS == IMEDIA_Play(pme->m_pMedia))
               pme->m_bPlayRec = TRUE;
         }
         break;

      case IDM_PM_RECORD:
         if (CPlayerWin_IsPause(pme))
            IMEDIA_Resume(pme->m_pMedia);
         else if (AEE_SUCCESS == IMEDIA_Record(pme->m_pMedia))
               pme->m_bPlayRec = TRUE;
         break;

      case IDM_PM_STOP:
         IMEDIA_Stop(pme->m_pMedia);
         break;

      case IDM_PM_REWIND:
         IMEDIA_Rewind(pme->m_pMedia, MP_SEEK_TIME);
         break;

      case IDM_PM_FF:
         IMEDIA_FastForward(pme->m_pMedia, MP_SEEK_TIME);
         break;

      case IDM_PM_PAUSE:
         if (CPlayerWin_IsPause(pme))
            IMEDIA_Resume(pme->m_pMedia);
         else 
            IMEDIA_Pause(pme->m_pMedia);
         break;

      case IDM_PM_UP:
      {

         uint16   wVol = pme->m_wVolume + MP_VOLUME_STEP;
         wVol = (wVol > AEE_MAX_VOLUME) ? AEE_MAX_VOLUME : wVol;
         IMEDIA_SetVolume(pme->m_pMedia, wVol);
         break;
      }

      case IDM_PM_DOWN:
      {
         int16    nVol = (int16)pme->m_wVolume - MP_VOLUME_STEP;
         nVol = (nVol < 0) ? 0 : nVol;
         IMEDIA_SetVolume(pme->m_pMedia, (uint16)nVol);
         break;
      }

      case IDM_PM_FULLSCRN:
         CPlayerWin_FullScreen(pme, (boolean)!pme->m_bFullScreen, FALSE);
         break;

      default:
         bRet = FALSE;
         break;
   }

   return bRet;
}

/*===========================================================================
   This function indicates IMedia is in paused state.
===========================================================================*/
static boolean CPlayerWin_IsPause(CPlayerWin * pme)
{
   boolean  bChg;
   int      nState = IMEDIA_GetState(pme->m_pMedia, &bChg);

   if (bChg)
      return FALSE;

   return (nState == MM_STATE_PLAY_PAUSE || nState == MM_STATE_RECORD_PAUSE);
}
 
/*===========================================================================
   This function saves the file name and sets the media data locally.
   Assumption: pmd is not NULL.
===========================================================================*/
static boolean CPlayerWin_SetMediaData(CPlayerWin * pme, AEEMediaData * pmd)
{
   if (!pmd->pData)
      return FALSE;

   pme->m_pszFile = (char *)pmd->pData;
   MEMCPY(&pme->m_md, pmd, sizeof(AEEMediaData));

   return TRUE;
}

/*===========================================================================
   This function toggles full screen mode and does a redraw.
===========================================================================*/
static boolean CPlayerWin_FullScreen(CPlayerWin * pme, boolean bFull, boolean bDeferRedraw)
{
   if (!pme->m_bImage)
      return FALSE;

   if (!pme->m_bFullScreen)
   {
      SETAEERECT(&pme->m_rectImage, 0, 0, pme->m_pOwner->m_cxWidth, pme->m_pOwner->m_cyHeight);
   }
   else
   {
      MEMCPY(&pme->m_rectImage, &pme->m_rectImageCopy, sizeof(AEERect));
   }

   if (CPlayerWin_IsMedia(pme))
      IMEDIA_SetRect(pme->m_pMedia, &pme->m_rectImage, NULL);
   else if (CPlayerWin_IsImage(pme))
      IIMAGECTL_SetRect(pme->m_pImageCtl, &pme->m_rectImage);

   pme->m_bFullScreen = bFull;

   CMediaPlayer_Redraw(pme->m_pOwner, bDeferRedraw);
   
   return TRUE;
}

/*===============================================================================

                     ProgCtl Functions