342 { |
358 { |
343 iPlaybackHead = 0; |
359 iPlaybackHead = 0; |
344 iMediaPlayerState = XA_PLAYSTATE_STOPPED; |
360 iMediaPlayerState = XA_PLAYSTATE_STOPPED; |
345 iMarkerPositionTimer->UseVideoPlayer(); |
361 iMarkerPositionTimer->UseVideoPlayer(); |
346 iPlayItfPositionUpdateTimer->UseVideoPlayer(); |
362 iPlayItfPositionUpdateTimer->UseVideoPlayer(); |
|
363 iPrefetchLevelUpdateTimer->UseVideoPlayer(); |
347 if (m_pWs && m_pScr && m_pWindow) |
364 if (m_pWs && m_pScr && m_pWindow) |
348 { |
365 { |
349 TRect videoExtent = TRect(m_pWindow->Size()); |
366 TRect videoExtent = TRect(m_pWindow->Size()); |
350 TRect clipRect = TRect(m_pWindow->Size()); |
367 TRect clipRect = TRect(m_pWindow->Size()); |
351 TAG_TIME_PROFILING_BEGIN; |
368 TAG_TIME_PROFILING_BEGIN; |
352 TRAP_IGNORE(iVideoPlayer->AddDisplayWindowL(*m_pWs, *m_pScr, *m_pWindow, videoExtent, clipRect)); |
369 TRAP_IGNORE(iVideoPlayer->AddDisplayWindowL(*m_pWs, *m_pScr, *m_pWindow, videoExtent, clipRect)); |
353 TRAP_IGNORE(iVideoPlayer->SetAutoScaleL(*m_pWindow, autoScale)); |
370 TRAP_IGNORE(iVideoPlayer->SetAutoScaleL(*m_pWindow, autoScale)); |
354 TAG_TIME_PROFILING_END; |
371 TAG_TIME_PROFILING_END; |
355 PRINT_TO_CONSOLE_TIME_DIFF; |
372 PRINT_TO_CONSOLE_TIME_DIFF; |
356 } |
373 } |
|
374 SetStreamInfo(); |
357 } |
375 } |
358 } |
376 } |
359 if (iActiveSchedulerWait && iActiveSchedulerWait->IsStarted()) |
377 if (iActiveSchedulerWait && iActiveSchedulerWait->IsStarted()) |
360 { |
378 { |
361 iActiveSchedulerWait->AsyncStop(); |
379 iActiveSchedulerWait->AsyncStop(); |
432 } |
450 } |
433 |
451 |
434 // From MRebufferCallback |
452 // From MRebufferCallback |
435 void CMMFBackendEngine::MvloLoadingStarted() |
453 void CMMFBackendEngine::MvloLoadingStarted() |
436 { |
454 { |
|
455 iPrefetchStatus = XA_PREFETCHSTATUS_UNDERFLOW; |
|
456 |
|
457 if(bStatusChangeMask) |
|
458 { |
|
459 XAAdaptEvent event = |
|
460 { |
|
461 XA_PREFETCHITFEVENTS, XA_PREFETCHEVENT_STATUSCHANGE, 0, NULL |
|
462 }; |
|
463 XAAdaptationBase_SendAdaptEvents( |
|
464 (XAAdaptationBaseCtx*) iAdaptContext, &event); |
|
465 } |
|
466 |
|
467 iPrefetchLevelUpdateTimer->Start(); |
437 } |
468 } |
438 |
469 |
439 void CMMFBackendEngine::MvloLoadingComplete() |
470 void CMMFBackendEngine::MvloLoadingComplete() |
440 { |
471 { |
441 //file playing |
472 iPrefetchStatus = XA_PREFETCHSTATUS_SUFFICIENTDATA; |
|
473 |
|
474 if(bStatusChangeMask) |
|
475 { |
|
476 XAAdaptEvent event = |
|
477 { |
|
478 XA_PREFETCHITFEVENTS, XA_PREFETCHEVENT_STATUSCHANGE, 0, NULL |
|
479 }; |
|
480 XAAdaptationBase_SendAdaptEvents( |
|
481 (XAAdaptationBaseCtx*) iAdaptContext, &event); |
|
482 } |
|
483 |
|
484 iPrefetchLevelUpdateTimer->Stop(); |
442 } |
485 } |
443 |
486 |
444 //MMdaAudioPlayerCallback |
487 //MMdaAudioPlayerCallback |
445 void CMMFBackendEngine::MapcInitComplete(TInt aError, |
488 void CMMFBackendEngine::MapcInitComplete(TInt aError, |
446 const TTimeIntervalMicroSeconds& aDuration) |
489 const TTimeIntervalMicroSeconds& aDuration) |
451 iMediaPlayerState = XA_PLAYSTATE_PLAYERUNINITIALIZED; |
494 iMediaPlayerState = XA_PLAYSTATE_PLAYERUNINITIALIZED; |
452 iMMFPlayerState = EPlayerClosed; |
495 iMMFPlayerState = EPlayerClosed; |
453 iMediaDuration = 0; |
496 iMediaDuration = 0; |
454 iMarkerPositionTimer->ResetPlayer(); |
497 iMarkerPositionTimer->ResetPlayer(); |
455 iPlayItfPositionUpdateTimer->ResetPlayer(); |
498 iPlayItfPositionUpdateTimer->ResetPlayer(); |
|
499 iPrefetchLevelUpdateTimer->ResetPlayer(); |
456 if (iErrorCode == KErrNone) |
500 if (iErrorCode == KErrNone) |
457 { |
501 { |
458 iMediaDuration = aDuration; |
502 iMediaDuration = aDuration; |
459 iPlaybackHead = 0; |
503 iPlaybackHead = 0; |
460 iMediaPlayerState = XA_PLAYSTATE_STOPPED; |
504 iMediaPlayerState = XA_PLAYSTATE_STOPPED; |
461 iMMFPlayerState = EPlayerOpened; |
505 iMMFPlayerState = EPlayerOpened; |
462 iMarkerPositionTimer->UseAudioPlayer(); |
506 iMarkerPositionTimer->UseAudioPlayer(); |
463 iPlayItfPositionUpdateTimer->UseAudioPlayer(); |
507 iPlayItfPositionUpdateTimer->UseAudioPlayer(); |
|
508 iPrefetchLevelUpdateTimer->UseAudioPlayer(); |
|
509 //set stream parameters |
|
510 SetStreamInfo(); |
464 } |
511 } |
465 if (iActiveSchedulerWait && iActiveSchedulerWait->IsStarted()) |
512 if (iActiveSchedulerWait && iActiveSchedulerWait->IsStarted()) |
466 { |
513 { |
467 iActiveSchedulerWait->AsyncStop(); |
514 iActiveSchedulerWait->AsyncStop(); |
468 } |
515 } |
1361 (XAAdaptationBaseCtx*) iAdaptContext, &xaevent); |
1414 (XAAdaptationBaseCtx*) iAdaptContext, &xaevent); |
1362 } |
1415 } |
1363 } |
1416 } |
1364 |
1417 |
1365 XAresult CMMFBackendEngine::GetNumStreams(XAuint32* numstreams) |
1418 XAresult CMMFBackendEngine::GetNumStreams(XAuint32* numstreams) |
1366 { |
1419 { |
1367 XAresult retVal(XA_RESULT_SUCCESS); |
1420 *numstreams = iNumStreams; |
1368 TInt bitRate(0); |
1421 return XA_RESULT_SUCCESS; |
1369 TInt numS(0); |
1422 } |
1370 if (iAPIBeingUsed == EAudioPlayerUtility) |
|
1371 { |
|
1372 numS = 1; |
|
1373 *numstreams = numS; |
|
1374 } |
|
1375 else if (iAPIBeingUsed == EVideoPlayerUtility) |
|
1376 { |
|
1377 TRAPD(err, bitRate = iVideoPlayer->VideoBitRateL()); |
|
1378 if (!err && bitRate) |
|
1379 { |
|
1380 numS++; |
|
1381 *numstreams = numS; |
|
1382 } |
|
1383 |
|
1384 bitRate = 0; |
|
1385 TRAP(err, bitRate = iVideoPlayer->AudioBitRateL()); |
|
1386 if (!err && bitRate) |
|
1387 { |
|
1388 numS++; |
|
1389 *numstreams = numS; |
|
1390 } |
|
1391 } |
|
1392 return retVal; |
|
1393 } |
|
1394 |
1423 |
1395 XAresult CMMFBackendEngine::GetStreamInfo(XAuint32 streamindex, |
1424 XAresult CMMFBackendEngine::GetStreamInfo(XAuint32 streamindex, |
1396 XAuint32* streamtype) |
1425 XAuint32* streamtype) |
1397 { |
1426 { |
1398 XAresult retVal(XA_RESULT_SUCCESS); |
1427 XAresult retVal(XA_RESULT_SUCCESS); |
1399 if (iAPIBeingUsed == EAudioPlayerUtility) |
1428 |
1400 { |
1429 switch (streamindex) |
1401 *streamtype = XA_DOMAINTYPE_AUDIO; |
1430 { |
1402 } |
1431 case 1: |
1403 else if (iAPIBeingUsed == EVideoPlayerUtility) |
1432 if(iAudioOnly) |
1404 { |
1433 { |
1405 switch (streamindex) |
1434 *streamtype = XA_DOMAINTYPE_AUDIO; |
1406 { |
1435 } |
1407 case 1: |
1436 else |
1408 *streamtype = XA_DOMAINTYPE_VIDEO; |
1437 { |
1409 break; |
1438 *streamtype = XA_DOMAINTYPE_VIDEO; |
1410 case 2: |
1439 } |
1411 *streamtype = XA_DOMAINTYPE_AUDIO; |
1440 break; |
1412 break; |
1441 case 2: |
1413 default: |
1442 *streamtype = XA_DOMAINTYPE_AUDIO; |
1414 retVal = XA_RESULT_PARAMETER_INVALID; |
1443 break; |
1415 break; |
1444 default: |
1416 } |
1445 retVal = XA_RESULT_PARAMETER_INVALID; |
1417 } |
1446 break; |
|
1447 } |
|
1448 |
1418 return retVal; |
1449 return retVal; |
1419 } |
1450 } |
1420 |
1451 |
1421 XAresult CMMFBackendEngine::GetVideoFrameSize(XAuint32* height, |
1452 XAresult CMMFBackendEngine::GetVideoFrameSize(XAuint32* height, |
1422 XAuint32* width, XAuint32* frameRate) |
1453 XAuint32* width, XAuint32* frameRate) |
1677 default: |
1706 default: |
1678 break; |
1707 break; |
1679 } |
1708 } |
1680 return retVal; |
1709 return retVal; |
1681 } |
1710 } |
|
1711 |
|
1712 XAresult CMMFBackendEngine::RegisterPrefetchCallback(xaPrefetchCallback callback) |
|
1713 { |
|
1714 if(*callback == NULL) |
|
1715 { |
|
1716 bPrefetchCallbackRegistered = EFalse; |
|
1717 } |
|
1718 else |
|
1719 { |
|
1720 bPrefetchCallbackRegistered = ETrue; |
|
1721 } |
|
1722 |
|
1723 return XA_RESULT_SUCCESS; |
|
1724 } |
|
1725 |
|
1726 XAresult CMMFBackendEngine::SetPrefetchLevelUpdatePeriod(XApermille pfPeriod) |
|
1727 { |
|
1728 if(iPrefetchLevelUpdateTimer) |
|
1729 { |
|
1730 iPrefetchLevelUpdateTimer->SetUpdateIncrement(pfPeriod); //In AL its effectively update increment and not time period |
|
1731 } |
|
1732 |
|
1733 return XA_RESULT_SUCCESS; |
|
1734 } |
|
1735 |
|
1736 XAresult CMMFBackendEngine::SetPrefetchCallbackEventsMask(XAuint32 eventflags) |
|
1737 { |
|
1738 if(eventflags & XA_PREFETCHEVENT_STATUSCHANGE) |
|
1739 { |
|
1740 bStatusChangeMask = ETrue; |
|
1741 } |
|
1742 |
|
1743 if(iPrefetchLevelUpdateTimer) |
|
1744 { |
|
1745 iPrefetchLevelUpdateTimer->SetCallbackEventMask(eventflags); |
|
1746 } |
|
1747 |
|
1748 return XA_RESULT_SUCCESS; |
|
1749 } |
|
1750 |
|
1751 XAresult CMMFBackendEngine::GetPrefetchStatus(XAuint32* status) |
|
1752 { |
|
1753 if(!status) |
|
1754 { |
|
1755 return XA_RESULT_PARAMETER_INVALID; |
|
1756 } |
|
1757 |
|
1758 *status = iPrefetchStatus; |
|
1759 |
|
1760 return XA_RESULT_SUCCESS; |
|
1761 } |
|
1762 |
|
1763 XAresult CMMFBackendEngine::GetPrefetchFillLevel(XApermille * level) |
|
1764 { |
|
1765 if(!level) |
|
1766 { |
|
1767 return XA_RESULT_PARAMETER_INVALID; |
|
1768 } |
|
1769 |
|
1770 TInt fillLevel = 0; |
|
1771 iPrefetchLevelUpdateTimer->GetLoadingProgress(fillLevel); |
|
1772 *level = fillLevel*10; //convert to permille |
|
1773 |
|
1774 return XA_RESULT_SUCCESS; |
|
1775 } |
|
1776 |
|
1777 void CMMFBackendEngine::SetStreamInfo() |
|
1778 { |
|
1779 TInt bitRate(0); |
|
1780 |
|
1781 TInt numStreams = iNumStreams; |
|
1782 bool bAudioOnly = iAudioOnly; |
|
1783 |
|
1784 //reset |
|
1785 iNumStreams = 0; |
|
1786 iAudioOnly = ETrue; |
|
1787 |
|
1788 if (iAPIBeingUsed == EAudioPlayerUtility) |
|
1789 { |
|
1790 iNumStreams = 1; |
|
1791 } |
|
1792 else if (iAPIBeingUsed == EVideoPlayerUtility) |
|
1793 { |
|
1794 TRAPD(err, bitRate = iVideoPlayer->VideoBitRateL()); |
|
1795 if (!err && bitRate) |
|
1796 { |
|
1797 iNumStreams++; |
|
1798 iAudioOnly = EFalse; |
|
1799 } |
|
1800 |
|
1801 bitRate = 0; |
|
1802 TRAP(err, bitRate = iVideoPlayer->AudioBitRateL()); |
|
1803 if (!err && bitRate) |
|
1804 { |
|
1805 iNumStreams++; |
|
1806 } |
|
1807 } |
|
1808 |
|
1809 if(numStreams != iNumStreams) |
|
1810 { |
|
1811 SendStreamInfoEvent(0); |
|
1812 } |
|
1813 else if(bAudioOnly != iAudioOnly) |
|
1814 { |
|
1815 SendStreamInfoEvent(1); |
|
1816 } |
|
1817 } |
|
1818 |
|
1819 void CMMFBackendEngine::SendStreamInfoEvent(TInt eventData) |
|
1820 { |
|
1821 if(iStreamInfoEventSubscribed) |
|
1822 { |
|
1823 XAAdaptEvent event = |
|
1824 { |
|
1825 XA_STREAMINFOEVENTS, eventData, 0, NULL |
|
1826 }; |
|
1827 XAAdaptationBase_SendAdaptEvents( |
|
1828 (XAAdaptationBaseCtx*) iAdaptContext, &event); |
|
1829 } |
|
1830 } |
|
1831 |
|
1832 XAresult CMMFBackendEngine::RegisterStreamInfoCallback(xaStreamEventChangeCallback cb) |
|
1833 { |
|
1834 if(*cb) |
|
1835 { |
|
1836 iStreamInfoEventSubscribed = ETrue; |
|
1837 } |
|
1838 else |
|
1839 { |
|
1840 iStreamInfoEventSubscribed = EFalse; |
|
1841 } |
|
1842 |
|
1843 return XA_RESULT_SUCCESS; |
|
1844 } |
|
1845 |
|
1846 XAresult CMMFBackendEngine::SetSourceRect(const XARectangle* rect) |
|
1847 { |
|
1848 XAresult retVal(XA_RESULT_PARAMETER_INVALID); |
|
1849 |
|
1850 switch (iMediaPlayerState) |
|
1851 { |
|
1852 case XA_PLAYSTATE_STOPPED: |
|
1853 case XA_PLAYSTATE_PAUSED: |
|
1854 case XA_PLAYSTATE_PLAYING: |
|
1855 if (iAPIBeingUsed == EAudioPlayerUtility) |
|
1856 { |
|
1857 retVal = XA_RESULT_FEATURE_UNSUPPORTED; |
|
1858 } |
|
1859 else |
|
1860 { |
|
1861 TRect inputrect(rect->left, rect->top, rect->left + rect->width, rect->top + rect->height); |
|
1862 TAG_TIME_PROFILING_BEGIN; |
|
1863 TRAPD(err, iVideoPlayer->SetCropRegionL(inputrect)); |
|
1864 TAG_TIME_PROFILING_END; PRINT_TO_CONSOLE_TIME_DIFF; |
|
1865 if(!err) |
|
1866 { |
|
1867 retVal = XA_RESULT_SUCCESS; |
|
1868 } |
|
1869 } |
|
1870 break; |
|
1871 case XA_PLAYSTATE_PLAYERUNINITIALIZED: |
|
1872 default: |
|
1873 break; |
|
1874 } |
|
1875 return retVal; |
|
1876 } |
|
1877 |
|
1878 XAresult CMMFBackendEngine::SetDestinationRect(const XARectangle* rect) |
|
1879 { |
|
1880 XAresult retVal(XA_RESULT_PARAMETER_INVALID); |
|
1881 |
|
1882 switch (iMediaPlayerState) |
|
1883 { |
|
1884 case XA_PLAYSTATE_STOPPED: |
|
1885 case XA_PLAYSTATE_PAUSED: |
|
1886 case XA_PLAYSTATE_PLAYING: |
|
1887 if (iAPIBeingUsed == EAudioPlayerUtility) |
|
1888 { |
|
1889 retVal = XA_RESULT_FEATURE_UNSUPPORTED; |
|
1890 } |
|
1891 else |
|
1892 { |
|
1893 TRect inputrect(rect->left, rect->top, rect->left + rect->width, rect->top + rect->height); |
|
1894 TAG_TIME_PROFILING_BEGIN; |
|
1895 TRAPD(err, iVideoPlayer->SetVideoExtentL(*m_pWindow,inputrect)); |
|
1896 TAG_TIME_PROFILING_END; PRINT_TO_CONSOLE_TIME_DIFF; |
|
1897 if(!err) |
|
1898 { |
|
1899 retVal = XA_RESULT_SUCCESS; |
|
1900 } |
|
1901 } |
|
1902 break; |
|
1903 case XA_PLAYSTATE_PLAYERUNINITIALIZED: |
|
1904 default: |
|
1905 break; |
|
1906 } |
|
1907 return retVal; |
|
1908 } |
|
1909 |
|
1910 XAresult CMMFBackendEngine::SetRotation(XAmillidegree rotation) |
|
1911 { |
|
1912 XAresult retVal(XA_RESULT_PARAMETER_INVALID); |
|
1913 |
|
1914 switch (iMediaPlayerState) |
|
1915 { |
|
1916 case XA_PLAYSTATE_STOPPED: |
|
1917 case XA_PLAYSTATE_PAUSED: |
|
1918 case XA_PLAYSTATE_PLAYING: |
|
1919 if (iAPIBeingUsed == EAudioPlayerUtility) |
|
1920 { |
|
1921 retVal = XA_RESULT_FEATURE_UNSUPPORTED; |
|
1922 } |
|
1923 else |
|
1924 { |
|
1925 TVideoRotation rot(EVideoRotationNone); |
|
1926 switch(rotation) |
|
1927 { |
|
1928 case 0: |
|
1929 rot = EVideoRotationNone; |
|
1930 break; |
|
1931 case 90000: |
|
1932 rot = EVideoRotationClockwise90; |
|
1933 break; |
|
1934 case 180000: |
|
1935 rot = EVideoRotationClockwise180; |
|
1936 break; |
|
1937 case 270000: |
|
1938 rot = EVideoRotationClockwise270; |
|
1939 break; |
|
1940 default: |
|
1941 rot = EVideoRotationNone; |
|
1942 break; |
|
1943 } |
|
1944 TAG_TIME_PROFILING_BEGIN; |
|
1945 TRAPD(err, iVideoPlayer->SetRotationL(*m_pWindow, rot)); |
|
1946 TAG_TIME_PROFILING_END; PRINT_TO_CONSOLE_TIME_DIFF; |
|
1947 if(!err) |
|
1948 { |
|
1949 retVal = XA_RESULT_SUCCESS; |
|
1950 } |
|
1951 } |
|
1952 break; |
|
1953 case XA_PLAYSTATE_PLAYERUNINITIALIZED: |
|
1954 default: |
|
1955 break; |
|
1956 } |
|
1957 return retVal; |
|
1958 } |
|
1959 |
|
1960 XAresult CMMFBackendEngine::SetScaleOptions(XAuint32 options) |
|
1961 { |
|
1962 XAresult retVal(XA_RESULT_PARAMETER_INVALID); |
|
1963 |
|
1964 switch (iMediaPlayerState) |
|
1965 { |
|
1966 case XA_PLAYSTATE_STOPPED: |
|
1967 case XA_PLAYSTATE_PAUSED: |
|
1968 case XA_PLAYSTATE_PLAYING: |
|
1969 if (iAPIBeingUsed == EAudioPlayerUtility) |
|
1970 { |
|
1971 retVal = XA_RESULT_FEATURE_UNSUPPORTED; |
|
1972 } |
|
1973 else |
|
1974 { |
|
1975 TAutoScaleType scale(EAutoScaleBestFit); |
|
1976 switch(options) |
|
1977 { |
|
1978 case XA_VIDEOSCALE_STRETCH: |
|
1979 scale = EAutoScaleStretch; |
|
1980 break; |
|
1981 case XA_VIDEOSCALE_FIT: |
|
1982 scale = EAutoScaleBestFit; |
|
1983 break; |
|
1984 case XA_VIDEOSCALE_CROP: |
|
1985 scale = EAutoScaleClip; |
|
1986 break; |
|
1987 default: |
|
1988 scale = EAutoScaleBestFit; |
|
1989 break; |
|
1990 } |
|
1991 TAG_TIME_PROFILING_BEGIN; |
|
1992 TRAPD(err, iVideoPlayer->SetAutoScaleL(*m_pWindow, scale)); |
|
1993 TAG_TIME_PROFILING_END; PRINT_TO_CONSOLE_TIME_DIFF; |
|
1994 if(!err) |
|
1995 { |
|
1996 retVal = XA_RESULT_SUCCESS; |
|
1997 } |
|
1998 } |
|
1999 break; |
|
2000 case XA_PLAYSTATE_PLAYERUNINITIALIZED: |
|
2001 default: |
|
2002 break; |
|
2003 } |
|
2004 return retVal; |
|
2005 } |
1682 |
2006 |
1683 extern "C" |
2007 extern "C" |
1684 { |
2008 { |
1685 |
2009 |
1686 int mmf_backend_engine_init(void** engine) |
2010 int mmf_backend_engine_init(void** engine) |
1925 |
2249 |
1926 XAresult mmf_playbackrateitf_get_playbackratecaps(void * context, XAboolean* forward, XAboolean* backward) |
2250 XAresult mmf_playbackrateitf_get_playbackratecaps(void * context, XAboolean* forward, XAboolean* backward) |
1927 { |
2251 { |
1928 return ((CMMFBackendEngine *) (context))->GetPlaybackRateCapabilities(forward,backward); |
2252 return ((CMMFBackendEngine *) (context))->GetPlaybackRateCapabilities(forward,backward); |
1929 } |
2253 } |
1930 } |
2254 XAresult mmf_prefetchstatusitf_register_callback( void * context, |
|
2255 xaPrefetchCallback callback) |
|
2256 { |
|
2257 return ((CMMFBackendEngine *) (context))->RegisterPrefetchCallback(callback); |
|
2258 } |
|
2259 XAresult mmf_prefetchstatusitf_set_fill_level_update_period( void * context, |
|
2260 XAmillisecond mSec) |
|
2261 { |
|
2262 return ((CMMFBackendEngine *) (context))->SetPrefetchLevelUpdatePeriod(mSec); |
|
2263 } |
|
2264 |
|
2265 |
|
2266 XAresult mmf_prefetchstatusitf_set_callback_events_mask(void * context, |
|
2267 XAuint32 evtMask) |
|
2268 { |
|
2269 return ((CMMFBackendEngine *) (context))->SetPrefetchCallbackEventsMask(evtMask); |
|
2270 } |
|
2271 |
|
2272 |
|
2273 XAresult mmf_prefetchstatusitf_get_status(void *context, XAuint32* status) |
|
2274 { |
|
2275 return ((CMMFBackendEngine *) (context))->GetPrefetchStatus(status); |
|
2276 } |
|
2277 |
|
2278 XAresult mmf_prefetchstatusitf_get_fill_level(void *context, XApermille * fillLevel) |
|
2279 { |
|
2280 return ((CMMFBackendEngine *) (context))->GetPrefetchFillLevel(fillLevel); |
|
2281 } |
|
2282 |
|
2283 XAresult mmf_streaminfoitf_register_callback(void * context, xaStreamEventChangeCallback callback) |
|
2284 { |
|
2285 return ((CMMFBackendEngine *) (context))->RegisterStreamInfoCallback(callback); |
|
2286 } |
|
2287 |
|
2288 XAresult mmf_videoppitf_set_sourcerectangle(void * context, const XARectangle* rect) |
|
2289 { |
|
2290 return ((CMMFBackendEngine *) (context))->SetSourceRect(rect); |
|
2291 } |
|
2292 |
|
2293 XAresult mmf_videoppitf_set_destinationrectangle(void * context, const XARectangle* rect) |
|
2294 { |
|
2295 return ((CMMFBackendEngine *) (context))->SetDestinationRect(rect); |
|
2296 } |
|
2297 |
|
2298 XAresult mmf_videoppitf_set_rotation(void * context, XAmillidegree rotation) |
|
2299 { |
|
2300 return ((CMMFBackendEngine *) (context))->SetRotation(rotation); |
|
2301 } |
|
2302 |
|
2303 XAresult mmf_videoppitf_set_scalingoptions(void * context, XAuint32 options) |
|
2304 { |
|
2305 return ((CMMFBackendEngine *) (context))->SetScaleOptions(options); |
|
2306 } |
|
2307 } |