khronosfws/openmax_al/src/mmf_adaptation/cmmfbackendengine.cpp
changeset 28 ebf79c79991a
parent 25 6f7ceef7b1d1
child 43 9894ed580e4a
equal deleted inserted replaced
25:6f7ceef7b1d1 28:ebf79c79991a
    21 #include <uri16.h>
    21 #include <uri16.h>
    22 #include "cmmfbackendengine.h"
    22 #include "cmmfbackendengine.h"
    23 #include "markerpositiontimer.h"
    23 #include "markerpositiontimer.h"
    24 #include "positionupdatetimer.h"
    24 #include "positionupdatetimer.h"
    25 #include "profileutilmacro.h"
    25 #include "profileutilmacro.h"
       
    26 #include <mmf/common/mmfvideoenums.h>
    26 
    27 
    27 extern "C"
    28 extern "C"
    28     {
    29     {
    29 #include "xaadaptationmmf.h"
    30 #include "xaadaptationmmf.h"
    30     }
    31     }
  1615             }
  1616             }
  1616         }
  1617         }
  1617     return retVal;
  1618     return retVal;
  1618     }
  1619     }
  1619 
  1620 
       
  1621 XAresult CMMFBackendEngine::SetPlaybackRate(XAint16 rate)
       
  1622     {
       
  1623     XAresult retVal(XA_RESULT_INTERNAL_ERROR);
       
  1624 
       
  1625     switch (iMediaPlayerState)
       
  1626         {
       
  1627         case XA_PLAYSTATE_STOPPED:
       
  1628         case XA_PLAYSTATE_PAUSED:
       
  1629         case XA_PLAYSTATE_PLAYING:
       
  1630             if (iAPIBeingUsed == EAudioPlayerUtility)
       
  1631                 {
       
  1632                 retVal = XA_RESULT_FEATURE_UNSUPPORTED;
       
  1633                 }
       
  1634             else
       
  1635                 {
       
  1636                 TRAPD(err, iVideoPlayer->SetPlayVelocityL(rate));
       
  1637                 if(!err)
       
  1638                     {
       
  1639                     retVal = XA_RESULT_SUCCESS; 
       
  1640                     }
       
  1641                 }
       
  1642             break;
       
  1643         case XA_PLAYSTATE_PLAYERUNINITIALIZED:
       
  1644         default:
       
  1645             break;
       
  1646         }
       
  1647     return retVal;
       
  1648     }
       
  1649 
       
  1650 XAresult CMMFBackendEngine::GetPlaybackRateCapabilities(XAboolean* forward,
       
  1651                                                         XAboolean* backward)
       
  1652     {
       
  1653     XAresult retVal(XA_RESULT_PARAMETER_INVALID);
       
  1654     
       
  1655     switch (iMediaPlayerState)
       
  1656         {
       
  1657         case XA_PLAYSTATE_STOPPED:
       
  1658         case XA_PLAYSTATE_PAUSED:
       
  1659         case XA_PLAYSTATE_PLAYING:
       
  1660             if (iAPIBeingUsed == EAudioPlayerUtility)
       
  1661                 {
       
  1662                 retVal = XA_RESULT_FEATURE_UNSUPPORTED;
       
  1663                 }
       
  1664             else
       
  1665                 {
       
  1666                 TVideoPlayRateCapabilities capability;
       
  1667                 TRAPD(err, iVideoPlayer->GetPlayRateCapabilitiesL(capability));
       
  1668                 if(!err)
       
  1669                     {
       
  1670                     *forward = capability.iPlayForward;
       
  1671                     *backward = capability.iPlayBackward;
       
  1672                     retVal = XA_RESULT_SUCCESS; 
       
  1673                     }
       
  1674                 }
       
  1675             break;
       
  1676         case XA_PLAYSTATE_PLAYERUNINITIALIZED:
       
  1677         default:
       
  1678             break;
       
  1679         }
       
  1680     return retVal;
       
  1681     }
       
  1682 
  1620 extern "C"
  1683 extern "C"
  1621     {
  1684     {
  1622 
  1685 
  1623     int mmf_backend_engine_init(void** engine)
  1686     int mmf_backend_engine_init(void** engine)
  1624         {
  1687         {
  1852 
  1915 
  1853     XAresult mmf_volumeitf_get_volume(void * context, XAuint32* volume)
  1916     XAresult mmf_volumeitf_get_volume(void * context, XAuint32* volume)
  1854         {
  1917         {
  1855         return ((CMMFBackendEngine *) (context))->GetVolume(volume);
  1918         return ((CMMFBackendEngine *) (context))->GetVolume(volume);
  1856         }
  1919         }
  1857     }
  1920 
       
  1921     XAresult mmf_playbackrateitf_set_playbackrate(void * context, XAint16 rate)
       
  1922         {
       
  1923         return ((CMMFBackendEngine *) (context))->SetPlaybackRate(rate);
       
  1924         }
       
  1925 
       
  1926     XAresult mmf_playbackrateitf_get_playbackratecaps(void * context, XAboolean* forward, XAboolean* backward)
       
  1927         {
       
  1928         return ((CMMFBackendEngine *) (context))->GetPlaybackRateCapabilities(forward,backward);
       
  1929         }
       
  1930     }